Skip to content
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.

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

fix: Commands iterator ignoring the hierarchy. #381

Merged
merged 2 commits into from
Jun 4, 2024
Merged
Changes from 1 commit
Commits
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
Next Next commit
Failing test: Commands iterator on hierarchical hugrs
aborgna-q committed Jun 4, 2024

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
commit fe404caaa14b0323728c4cd5152152960f00f6e9
43 changes: 38 additions & 5 deletions tket2/src/circuit/command.rs
Original file line number Diff line number Diff line change
@@ -465,17 +465,19 @@ impl<'circ, T: HugrView> std::fmt::Debug for CommandIterator<'circ, T> {
mod test {
use hugr::builder::{Container, DFGBuilder, Dataflow, DataflowHugr};
use hugr::extension::prelude::QB_T;
use hugr::hugr::hugrmut::HugrMut;
use hugr::ops::handle::NodeHandle;
use hugr::ops::{NamedOp, Value};
use hugr::std_extensions::arithmetic::float_ops::FLOAT_OPS_REGISTRY;
use hugr::std_extensions::arithmetic::float_types::ConstF64;
use hugr::types::FunctionType;
use itertools::Itertools;
use rstest::{fixture, rstest};
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

use crate::extension::REGISTRY;
use crate::utils::build_simple_circuit;
use crate::utils::{build_module_with_circuit, build_simple_circuit};
use crate::Tk2Op;

use super::*;
@@ -487,16 +489,47 @@ mod test {
};
}

#[test]
fn iterate_commands() {
let circ = build_simple_circuit(2, |circ| {
/// 2-qubit circuit with a Hadamard, a CNOT, and a T gate.
#[fixture]
fn simple_circuit() -> Circuit {
build_simple_circuit(2, |circ| {
circ.append(Tk2Op::H, [0])?;
circ.append(Tk2Op::CX, [0, 1])?;
circ.append(Tk2Op::T, [1])?;
Ok(())
})
.unwrap();
.unwrap()
}

/// 2-qubit circuit with a Hadamard, a CNOT, and a T gate,
/// defined inside a module.
#[fixture]
fn simple_module() -> Circuit {
build_module_with_circuit(2, |circ| {
circ.append(Tk2Op::H, [0])?;
circ.append(Tk2Op::CX, [0, 1])?;
circ.append(Tk2Op::T, [1])?;
Ok(())
})
.unwrap()
}

/// 2-qubit circuit with a Hadamard, a CNOT, and a T gate,
/// defined inside a module containing other circuits.
#[fixture]
fn module_with_circuits() -> Circuit {
let mut module = simple_module();
let other_circ = simple_circuit();
let hugr = module.hugr_mut();
hugr.insert_hugr(hugr.root(), other_circ.into_hugr());
return module;
}

#[rstest]
#[case::dfg_rooted(simple_circuit())]
#[case::module_rooted(simple_module())]
#[case::complex_module_rooted(module_with_circuits())]
fn iterate_commands_simple(#[case] circ: Circuit) {
assert_eq!(CommandIterator::new(&circ).count(), 3);

let tk2op_name = |op: Tk2Op| op.exposed_name();
34 changes: 28 additions & 6 deletions tket2/src/utils.rs
Original file line number Diff line number Diff line change
@@ -1,12 +1,14 @@
//! Utility functions for the library.

use hugr::builder::{Container, DataflowSubContainer, FunctionBuilder, HugrBuilder, ModuleBuilder};
use hugr::extension::PRELUDE_REGISTRY;
use hugr::ops::handle::NodeHandle;
use hugr::types::{Type, TypeBound};
use hugr::Hugr;
use hugr::{
builder::{BuildError, CircuitBuilder, DFGBuilder, Dataflow, DataflowHugr},
extension::prelude::QB_T,
types::FunctionType,
Hugr,
};

use crate::circuit::Circuit;
@@ -15,12 +17,12 @@ pub(crate) fn type_is_linear(typ: &Type) -> bool {
!TypeBound::Copyable.contains(typ.least_upper_bound())
}

// utility for building simple qubit-only circuits.
/// Utility for building simple qubit-only circuits.
#[allow(unused)]
pub(crate) fn build_simple_circuit(
num_qubits: usize,
f: impl FnOnce(&mut CircuitBuilder<DFGBuilder<Hugr>>) -> Result<(), BuildError>,
) -> Result<Circuit, BuildError> {
pub(crate) fn build_simple_circuit<F>(num_qubits: usize, f: F) -> Result<Circuit, BuildError>
where
F: FnOnce(&mut CircuitBuilder<DFGBuilder<Hugr>>) -> Result<(), BuildError>,
{
let qb_row = vec![QB_T; num_qubits];
let mut h = DFGBuilder::new(FunctionType::new(qb_row.clone(), qb_row))?;

@@ -35,6 +37,26 @@ pub(crate) fn build_simple_circuit(
Ok(hugr.into())
}

/// Utility for building a module with a single circuit definition.
#[allow(unused)]
pub(crate) fn build_module_with_circuit<F>(num_qubits: usize, f: F) -> Result<Circuit, BuildError>
where
F: FnOnce(&mut CircuitBuilder<FunctionBuilder<&mut Hugr>>) -> Result<(), BuildError>,
{
let mut builder = ModuleBuilder::new();
let circ = {
let qb_row = vec![QB_T; num_qubits];
let circ_signature = FunctionType::new(qb_row.clone(), qb_row);
let mut dfg = builder.define_function("main", circ_signature.into())?;
let mut circ = dfg.as_circuit(dfg.input_wires());
f(&mut circ)?;
let qbs = circ.finish();
dfg.finish_with_outputs(qbs)?
};
let hugr = builder.finish_hugr(&PRELUDE_REGISTRY)?;
Ok(Circuit::new(hugr, circ.node()))
}

// Test only utils
#[allow(dead_code)]
#[allow(unused_imports)]