Memory Qubits by fedimser · Pull Request #3159 · microsoft/qdk

fedimser · 2026-04-26T18:01:59Z

This PR adds support for new Q# type MemoryQubit and extends standard library with operations on it.

A “Memory Qubit” is a useful abstraction in quantum computing. It is a logical qubit on which gates or measurements are not performed directly. It can only hold a quantum state. When we want to do something with that state, we must “load” it to a regular (“compute”) qubit. When we want to retain state of compute qubit for a while but don’t perform computations, we can “store” it to a memory qubit.

This PR contains:

MemoryQubit type definition and changes to compiler to support it.
Definitions of 4 intrinsics to allocate, free, load and store qubits.
Compiler changes to support use syntax (similarly to Qubits) and translate it to allocation instrinsic.
Compiler changes to automatically free MemoryQubit when going out of scope.
New 3 methods in Backend (memory_qubit_allocate, memory_qubit_load, memory_qubit_store). Together with existing qubit_free, this is the interface between the Q# language and backends.
Supported MemoryQubits in resource estimation backend (count.qs). In other backends use default implementation that uses Qubits as MemoryQubits and Reset+SWAP for stores and loads (which is correct for simulation).
Added Std.MemoryQubits which defines operations to work with memory qubits (Load, Store, LoadArray, StoreArray, DoComputation) that internally delegate to 2 intrinsics (load/store).
Added short description of MemoryQubits in Std.MemoryQubits.
Added tests for syntax, simulator and resource estimation in single rust test file.

github-actions · 2026-04-27T16:48:16Z

Change in memory usage detected by benchmark.

Memory Report for `fd2595c`

Test	This Branch	On Main	Difference
compile core + standard lib	26549011 bytes	24572311 bytes	1976700 bytes

github-actions · 2026-04-29T17:53:18Z

Change in memory usage detected by benchmark.

Memory Report for `6c5e7da`

Test	This Branch	On Main	Difference
compile core + standard lib	26549011 bytes	24572311 bytes	1976700 bytes

swernli

Reviewed code so far, and provided some feedback. Also, it looks like the pipeline is blocked due to some pending merge conflicts.

swernli · 2026-05-05T17:40:54Z

 }

+/// Asserts that given Q# expression fails to compile with given error message.
+pub fn test_compile_fails(expr: &str, lib: &str, expected_error_substring: &str) {


Is this new function necessary? There are other tests that use test_expression_fails defined above and then expect on the output string. Would that be sufficient for new tests?

swernli · 2026-05-05T17:42:27Z

+    logical_counts_expr(&mut interpreter, expr)
+        .unwrap_or_else(|errs| panic_with_resource_estimation_errors(&errs))
+}
+
+fn panic_with_resource_estimation_errors(errs: &[ResourceEstimatorError]) -> ! {
+    let joined = errs
+        .iter()
+        .map(|e| format!("{e}:{e:?}"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    panic!("resource estimation failed:\n{joined}");
+}


Rather than have a utility to panic with all the errors joined, you could just use the first error returned. Most of the APIs other than compile use a vector of errors for compatibility sake with parts of the infra but only ever return one error.

swernli · 2026-05-05T17:50:26Z

+/// Memory register to transform.
+/// ## op
+/// Operation to apply to the temporary compute buffer.
+operation DoComputation(mem_qs : MemoryQubit[], op : Qubit[] => Unit) : Unit {


I feel like "do" reads weird here... I think ApplyComputation would better match our naming patterns.

swernli · 2026-05-05T17:53:37Z

 }

+// MemoryQubit operations.
+operation __quantum__qis__memory_qubit_load(memory_qubit : MemoryQubit, qubit : Qubit) : Unit {


To follow QIR naming conventions, things with __qis__ should end in __body, making this one __quantum__qis__memory_qubit_load__body. I think the "qubit" part may be a bit redundant, since we already have "quantum" and "qis" which stands for Quantum Intruction Set, so __quantum__qis__memory_load__body would be fine. Likewise the corresponding operation below would be __quantum__qis__memory_store__body.

Side note: it seems awkward to add __body but it is really only to differentiation between the inverse/adjoint operations, which have the __adj suffix.

swernli · 2026-05-05T17:56:12Z

+// # Description
+// Prepares a compute qubit in |1>, stores it in a memory qubit, then loads
+// it back and measures. The result should be `One`.
+
+import Std.MemoryQubits.*;
+
+operation Main() : Result {
+    use (q, mem) = (Qubit(), MemoryQubit());
+
+    X(q);
+    Store(q, mem);
+    Load(mem, q);
+
+    return MResetZ(q);
+}


I think this sample could use some additional explanatory text in the top level description and comments in the body itself, like our other language samples do. The motivation is both to help educate users and to act as guidance for LLMs, so it's woth explaining the patterns and motivations here.

swernli · 2026-05-05T18:31:07Z

            "__quantum__qis__mresetz__body" => {
                Ok(self.measure_qubit(builder::mresetz_decl(), args_value))
            }
+            "__quantum__qis__memory_qubit_load" | "__quantum__qis__memory_qubit_load__body" => {


Once the name fix in the libraries is added, only the __body name is needed here. Same for the case below.

swernli · 2026-05-05T18:32:30Z

@@ -1766,6 +1770,56 @@ impl<'a> PartialEvaluator<'a> {
            "__quantum__qis__mresetz__body" => {
                Ok(self.measure_qubit(builder::mresetz_decl(), args_value))
            }


Looks like this file is missing some clippy lint clean up. The two cases for load and store are identical, since the arguments ordering is enough to change the directionality of the operation.

swernli · 2026-05-05T18:34:31Z

                    .try_into()
                    .expect("could not convert qubit ID to u32"),
            )),
+            Value::MemoryQubit(q) => Operand::Literal(Literal::Qubit(


This can be combined with the qubit case above.

swernli · 2026-05-05T18:35:06Z

+        let callable = Callable {
+            name: "__quantum__qis__swap__body".to_string(),
+            input_type: vec![rir::Ty::Prim(rir::Prim::Qubit), rir::Ty::Prim(rir::Prim::Qubit)],
+            output_type: None,
+            body: None,
+            call_type: CallableType::Regular,
+        };


to match the pattern we have above, this should be adder to the builder class instead of inlined here.

swernli · 2026-05-05T18:38:21Z

-            "__quantum__rt__qubit_allocate" | "__quantum__rt__qubit_borrow" => {
+            "__quantum__rt__qubit_allocate"
+            | "__quantum__rt__qubit_borrow"
+            | "__quantum__rt__memory_qubit_allocate" => {


no action on this, just a note to confirm understanding: this is consistent with the goal of supporting memory qubit programs as normal compute programs in QIR, as this does not guarantee that the two qubit types will use distinct pools, and if/when we want to support memory qubits as a distinct pool of ids we'd want to differentiate the two kinds of allocation/release calls with separate management (among other changes, like emitting load and store directly). Does that match your expectation as well?

swernli and others added 7 commits March 17, 2026 11:08

WIP: introduce memory type and API, no support yet

ace3ed6

Basic support

35cb700

use load/store intrinsic

fb37316

Merge remote-tracking branch 'origin/main' into swernli/qmem

cd0e0d3

Merge branch 'main' into fedimser/qmem

31fe45b

Add a simple test for QMem

33507f3

add resource estimation test

e698099

github-advanced-security AI found potential problems Apr 26, 2026

View reviewed changes

Comment thread source/compiler/qsc_eval/src/tests.rs Fixed

Comment thread source/compiler/qsc_eval/src/tests.rs Fixed

Comment thread source/compiler/qsc_eval/src/tests.rs Fixed

fedimser added 8 commits April 26, 2026 12:00

restructure tests

9d776fc

correct resource estimation

2aab860

define 4 intrinsics

e240506

rename type to MemoryQubit

8548d11

Support use syntax and auto-freeing

3674b45

Add tests and dtandard library helpers

8bd906e

docs

832d99b

small fixes

8b39cfc

fedimser changed the title ~~[Draft] Memory Qubits~~ Memory Qubits Apr 27, 2026

fedimser added 2 commits April 26, 2026 18:19

clippy

f886255

small fixes

809c3cd

fedimser marked this pull request as ready for review April 27, 2026 16:45

fedimser requested review from ScottCarda-MS, billti, idavis, minestarks, orpuente-MS and swernli as code owners April 27, 2026 16:45

fedimser marked this pull request as draft April 27, 2026 16:49

fedimser marked this pull request as ready for review April 29, 2026 17:37

add a sample

7b609c4

swernli reviewed May 5, 2026

View reviewed changes

Conversation

fedimser commented Apr 26, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

github-actions Bot commented Apr 27, 2026

Memory Report for fd2595c

Uh oh!

github-actions Bot commented Apr 29, 2026

Memory Report for 6c5e7da

Uh oh!

swernli left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

fedimser commented Apr 26, 2026 •

edited

Loading

Memory Report for `fd2595c`

Memory Report for `6c5e7da`