mod compat;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct TokenId(pub u32);
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct WireId(pub u32);
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ClassicalId(pub u32);
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BasisShape {
pub bits: u8,
}
impl BasisShape {
pub const UNIT: Self = Self { bits: 0 };
pub const BIT: Self = Self { bits: 1 };
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub enum Effect {
Unitary,
Iso,
Observe,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct QuantumPort {
pub token: TokenId,
pub wires: Vec<WireId>,
pub shape: BasisShape,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RawProgram {
pub quantum_inputs: Vec<QuantumPort>,
pub classical_inputs: Vec<ClassicalId>,
pub operations: Vec<RawOp>,
pub quantum_outputs: Vec<TokenId>,
pub classical_outputs: Vec<ClassicalId>,
pub declared_effect: Effect,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SingleGate {
H,
X,
Z,
T,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ScalarPhase {
MinusOne,
EighthTurn,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum UnitaryStep {
Gate {
gate: SingleGate,
target_index: usize,
},
Cnot {
control_index: usize,
target_index: usize,
},
Toffoli {
control_a_index: usize,
control_b_index: usize,
target_index: usize,
},
ScalarPhase(ScalarPhase),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BitControl {
pub index: usize,
pub when_one: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CircuitAction {
Contract {
indices: Vec<usize>,
evidence: std::sync::Arc<crate::contract::function::FunctionEvidence>,
adjoint: bool,
},
Hadamard {
target: usize,
},
Monomial {
indices: Vec<usize>,
permutation: Vec<u16>,
phases: Vec<u8>,
},
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CircuitStep {
pub controls: Vec<BitControl>,
pub action: CircuitAction,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ProtectedRegion {
Source,
Ancilla,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ProtectedBit {
pub region: ProtectedRegion,
pub index: u8,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Control {
pub bit: ProtectedBit,
pub when_one: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ProtectedUse {
ProtectedGate { bit: ProtectedBit, gate: SingleGate },
ControlledTargetGate {
controls: Vec<Control>,
target_index: usize,
gate: SingleGate,
},
ControlledPhase {
controls: Vec<Control>,
phase: ScalarPhase,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TargetTransition {
pub input: TokenId,
pub output: TokenId,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct QuantumPhi {
pub then_token: TokenId,
pub else_token: TokenId,
pub output: TokenId,
pub output_wires: Vec<WireId>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ClassicalPhi {
pub then_id: ClassicalId,
pub else_id: ClassicalId,
pub output: ClassicalId,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum RawOp {
CertifiedCompute {
source: TokenId,
source_out: TokenId,
ancilla_wires: Vec<WireId>,
function: Vec<u16>,
use_steps: Vec<CircuitStep>,
logical_steps: Vec<CircuitStep>,
},
ApplyUnitary {
input: TokenId,
output: TokenId,
steps: Vec<CircuitStep>,
},
Init0 {
output: TokenId,
wire: WireId,
},
Gate {
gate: SingleGate,
input: TokenId,
output: TokenId,
},
Cnot {
control: TokenId,
target: TokenId,
control_out: TokenId,
target_out: TokenId,
},
Toffoli {
control_a: TokenId,
control_b: TokenId,
target: TokenId,
control_a_out: TokenId,
control_b_out: TokenId,
target_out: TokenId,
},
QuantumIf {
control: TokenId,
target: TokenId,
control_out: TokenId,
target_out: TokenId,
zero_ops: Vec<UnitaryStep>,
one_ops: Vec<UnitaryStep>,
},
Split {
input: TokenId,
left: TokenId,
right: TokenId,
left_bits: u8,
},
Join {
left: TokenId,
right: TokenId,
output: TokenId,
},
LiftBasis {
input: TokenId,
output: TokenId,
output_wires: Vec<WireId>,
table: Vec<u16>,
},
MeasureZ {
input: TokenId,
output: ClassicalId,
},
Reset {
input: TokenId,
output: TokenId,
fresh_wire: WireId,
},
Discard {
input: TokenId,
},
ClassicalConst {
value: bool,
output: ClassicalId,
},
ClassicalNot {
input: ClassicalId,
output: ClassicalId,
},
ClassicalXor {
left: ClassicalId,
right: ClassicalId,
output: ClassicalId,
},
ClassicalAnd {
left: ClassicalId,
right: ClassicalId,
output: ClassicalId,
},
ClassicalBranch {
condition: ClassicalId,
then_ops: Vec<RawOp>,
else_ops: Vec<RawOp>,
quantum_phis: Vec<QuantumPhi>,
classical_phis: Vec<ClassicalPhi>,
},
ComputeUseUncompute {
source: TokenId,
source_out: TokenId,
targets: Vec<TargetTransition>,
ancilla_wires: Vec<WireId>,
function: Vec<u16>,
use_ops: Vec<ProtectedUse>,
},
}
impl Drop for RawOp {
fn drop(&mut self) {
let mut pending = Vec::new();
if let Self::ClassicalBranch {
then_ops, else_ops, ..
} = self
{
pending.append(then_ops);
pending.append(else_ops);
}
while let Some(mut op) = pending.pop() {
if let Self::ClassicalBranch {
then_ops, else_ops, ..
} = &mut op
{
pending.append(then_ops);
pending.append(else_ops);
}
}
}
}