Skip to content

Alternative version of relabeling #2083

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 2 commits into from
Closed

Alternative version of relabeling #2083

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
479eb66
Fix `Relabel` for odd size arrays
swernli Dec 29, 2024
95bf67b
Alternative version of relabeling
Dec 30, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
83 changes: 38 additions & 45 deletions compiler/qsc_eval/src/intrinsic.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -347,7 +347,7 @@ fn two_qubit_rotation(
pub fn qubit_relabel(
arg: Value,
arg_span: PackageSpan,
mut swap: impl FnMut(usize, usize),
swap: impl FnMut(usize, usize),
) -> Result<Value, Error> {
let [left, right] = unwrap_tuple(arg);
let left = left.unwrap_array();
Expand Down Expand Up @@ -377,51 +377,44 @@ pub fn qubit_relabel(
return Err(Error::RelabelingMismatch(arg_span));
}

let mut map = FxHashMap::default();
map.reserve(left.len());
for (l, r) in left.into_iter().zip(right.into_iter()) {
if l == r {
permutation_via_transpositions(&right, &left, swap);
Ok(Value::unit())
}

/// Performs arbitrary permutation of object labels using label swap function.
/// Upon completions an object labeled with ``original_labels``[i] will be labeled ``permuted_labels``[i].
/// Transposition function swaps labels on objects identified by their labels.
pub fn permutation_via_transpositions(
original_labels: &[usize], // Original placement of labels
permuted_labels: &[usize], // Desired placement of labels
mut swap: impl FnMut(usize, usize), // Swap these labels
) {
// Create a map of objects that may potentially need relabeling.
let mut object_with_label = FxHashMap::default();
object_with_label.reserve(original_labels.len());
for (i, &label) in original_labels.iter().enumerate() {
object_with_label.insert(label, i);
}

// While we have more objects that need relabeling
while let Some((&label, &i)) = object_with_label.iter().next() {
// Currently label is on object i. What is the desired label for it?
let desired = permuted_labels[i];
if desired == label {
// When desired label and current label is the same -
// remove from the map. We are done with this object.
object_with_label.remove(&label);
continue;
}
match (map.contains_key(&l), map.contains_key(&r)) {
(false, false) => {
// Neither qubit has been relabeled yet.
swap(l, r);
map.insert(l, r);
map.insert(r, l);
}
(false, true) => {
// The right qubit has been relabeled, so we need to swap the left qubit with the
// qubit that the right qubit was relabeled to.
let mapped = *map
.keys()
.find(|k| map[*k] == r)
.expect("mapped qubit should be present as both key and value");
swap(l, mapped);
map.insert(l, r);
map.insert(mapped, l);
}
(true, false) => {
// The left qubit has been relabeled, so we swap the qubits as normal but
// remember the new mapping of the right qubit.
let mapped = *map.get(&l).expect("mapped qubit should be present");
swap(l, r);
map.insert(l, r);
map.insert(r, mapped);
}
(true, true) => {
// Both qubits have been relabeled, so we need to swap the mapped right qubit with
// the left qubit and remember the new mapping of both qubits.
let mapped_l = *map.get(&l).expect("mapped qubit should be present");
let mapped_r = *map.get(&r).expect("mapped qubit should be present");
if mapped_l != r && mapped_r != l {
swap(mapped_r, l);
map.insert(mapped_r, mapped_l);
map.insert(l, r);
}
}
}
// Which object has the desired label now? It's object j.
let &j = object_with_label
.get(&desired)
.expect("Missing label that still needs relabeling.");
// Swap labels on objects with current and desired label.
swap(label, desired);
// We are done with the desired label, remove it for map.
object_with_label.remove(&desired);
// Now label is on object j and it may still need relabeling.
object_with_label.insert(label, j);
}

Ok(Value::unit())
}
108 changes: 106 additions & 2 deletions library/src/tests/canon.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -154,6 +154,78 @@ fn check_relabel_rotational_permutation_alternate_expression() {
);
}

#[test]
fn check_relabel_rotational_permutation_size_4() {
test_expression(
"{
use qs = Qubit[4];
// Prepare |01+0⟩
X(qs[1]);
H(qs[2]);
Relabel(qs, qs[2...] + qs[0..1]);
// Expected state is |+001⟩, perform adjoint to get back to ground state.
H(qs[0]);
X(qs[Length(qs)-1]);
// Qubit release will fail if the state is not |000⟩
}",
&Value::unit(),
);
}

#[test]
fn check_relabel_rotational_permutation_size_5() {
test_expression(
"{
use qs = Qubit[5];
// Prepare |01+00⟩
X(qs[1]);
H(qs[2]);
Relabel(qs, qs[2...] + qs[0..1]);
// Expected state is |+0001⟩, perform adjoint to get back to ground state.
H(qs[0]);
X(qs[Length(qs)-1]);
// Qubit release will fail if the state is not |000⟩
}",
&Value::unit(),
);
}

#[test]
fn check_relabel_rotational_permutation_size_6() {
test_expression(
"{
use qs = Qubit[6];
// Prepare |01+000⟩
X(qs[1]);
H(qs[2]);
Relabel(qs, qs[2...] + qs[0..1]);
// Expected state is |+00001⟩, perform adjoint to get back to ground state.
H(qs[0]);
X(qs[Length(qs)-1]);
// Qubit release will fail if the state is not |000⟩
}",
&Value::unit(),
);
}

#[test]
fn check_relabel_rotational_permutation_size_7() {
test_expression(
"{
use qs = Qubit[7];
// Prepare |01+0000⟩
X(qs[1]);
H(qs[2]);
Relabel(qs, qs[2...] + qs[0..1]);
// Expected state is |+000001⟩, perform adjoint to get back to ground state.
H(qs[0]);
X(qs[Length(qs)-1]);
// Qubit release will fail if the state is not |000⟩
}",
&Value::unit(),
);
}

#[test]
fn check_relabel_four_qubit_shuffle_permutation() {
test_expression(
Expand All @@ -162,12 +234,44 @@ fn check_relabel_four_qubit_shuffle_permutation() {
// Prepare |01+i⟩
X(qs[1]);
H(qs[2]);
Y(qs[3]);
H(qs[3]);
S(qs[3]);
H(qs[3]);
Relabel([qs[0], qs[1], qs[2], qs[3]], [qs[1], qs[0], qs[3], qs[2]]);
// Expected state is |10i+⟩, perform adjoint to get back to ground state.
X(qs[0]);
Y(qs[2]);
H(qs[2]);
Adjoint S(qs[2]);
H(qs[2]);
H(qs[3]);
// Qubit release will fail if the state is not |0000⟩
}",
&Value::unit(),
);
}

#[test]
fn check_relabel_five_qubit_shuffle_permutation() {
test_expression(
"{
use qs = Qubit[5];
// Prepare |01+i-⟩
X(qs[1]);
H(qs[2]);
H(qs[3]);
S(qs[3]);
H(qs[3]);
H(qs[4]);
Z(qs[4]);
Relabel([qs[0], qs[1], qs[2], qs[3], qs[4]], [qs[1], qs[0], qs[3], qs[4], qs[2]]);
// Expected state is |10i-+⟩, perform adjoint to get back to ground state.
X(qs[0]);
H(qs[2]);
Adjoint S(qs[2]);
H(qs[2]);
Z(qs[3]);
H(qs[3]);
H(qs[4]);
// Qubit release will fail if the state is not |0000⟩
}",
&Value::unit(),
Expand Down