From 483e9e6ce9fbb1440992e916ec743ce0eff0ab5a Mon Sep 17 00:00:00 2001 From: hachem Date: Sat, 12 Oct 2024 16:56:12 +0200 Subject: Simplify and start rework of gate application --- examples/simple_gates/src/main.rs | 6 +-- examples/visualizers/src/main.rs | 4 +- libpsi-core/src/core/circuit.rs | 16 +++---- libpsi-core/src/core/component.rs | 16 +++---- libpsi-core/src/core/runtime.rs | 16 +++---- libpsi-core/src/maths/matrix.rs | 2 +- libpsi-core/src/runtimes/basic_rt.rs | 90 +++--------------------------------- 7 files changed, 35 insertions(+), 115 deletions(-) diff --git a/examples/simple_gates/src/main.rs b/examples/simple_gates/src/main.rs index 5c529a6..f48c935 100644 --- a/examples/simple_gates/src/main.rs +++ b/examples/simple_gates/src/main.rs @@ -2,9 +2,9 @@ use libpsi_core::*; fn main() { let mut circuit = QuantumCircuit::new(2, 2); - circuit.apply(&gates::HADAMARD, &[], &[0]); - circuit.apply(&gates::CNOT, &[0], &[1]); + circuit.apply(&gates::HADAMARD, &[], 0); + circuit.apply(&gates::CNOT, &[0], 1); let runtime = BasicRT::new(&circuit); - runtime.execute(1024); + runtime.execute(1); } diff --git a/examples/visualizers/src/main.rs b/examples/visualizers/src/main.rs index ed5755a..d1fdb6e 100644 --- a/examples/visualizers/src/main.rs +++ b/examples/visualizers/src/main.rs @@ -3,8 +3,8 @@ use libpsi_visualizer::*; fn main() { let mut circuit = QuantumCircuit::new(2, 2); - circuit.apply(&gates::HADAMARD, &[], &[0]); - circuit.apply(&gates::CNOT, &[0], &[1]); + circuit.apply(&gates::HADAMARD, &[], 0); + circuit.apply(&gates::CNOT, &[0], 1); let mut visualizer = HorizontalCLIVisualizer::new(&circuit); visualizer.render(); diff --git a/libpsi-core/src/core/circuit.rs b/libpsi-core/src/core/circuit.rs index 183c4a2..635066a 100644 --- a/libpsi-core/src/core/circuit.rs +++ b/libpsi-core/src/core/circuit.rs @@ -1,14 +1,14 @@ -use super::{ClassicalRegister, QuantumBit, QuantumGate}; +use super::{ClassicalRegister, QuantumGate, QuantumRegister}; #[derive(Clone)] pub struct QuantumCircuitInstruction { - pub target_indices: Vec, + pub target_bit: usize, pub control_indices: Vec, pub gate: QuantumGate, } pub struct QuantumCircuit { - quantum_bits: Vec, + quantum_register: QuantumRegister, classical_register: ClassicalRegister, instructions: Vec, } @@ -16,22 +16,22 @@ pub struct QuantumCircuit { impl QuantumCircuit { pub fn new(quantum_bit_count: usize, classical_bit_count: usize) -> QuantumCircuit { QuantumCircuit { - quantum_bits: vec![QuantumBit::state_0(); quantum_bit_count], + quantum_register: QuantumRegister::new(quantum_bit_count), classical_register: ClassicalRegister::new(classical_bit_count), instructions: Vec::new(), } } - pub fn apply(&mut self, gate: &QuantumGate, control_bits: &[usize], target_bits: &[usize]) { + pub fn apply(&mut self, gate: &QuantumGate, control_bits: &[usize], target_bit: usize) { self.instructions.push(QuantumCircuitInstruction { gate: gate.clone(), - target_indices: target_bits.to_vec(), + target_bit, control_indices: control_bits.to_vec(), }); } - pub fn get_quantum_bits(&self) -> Vec { - self.quantum_bits.clone() + pub fn get_quantum_register(&self) -> QuantumRegister { + self.quantum_register.clone() } pub fn get_classical_registers(&self) -> ClassicalRegister { diff --git a/libpsi-core/src/core/component.rs b/libpsi-core/src/core/component.rs index be5fbca..d2dc781 100644 --- a/libpsi-core/src/core/component.rs +++ b/libpsi-core/src/core/component.rs @@ -4,7 +4,8 @@ use crate::{complex, ColumnVector, Complex, Matrix, Vector, VectorMatrix}; use core::ops; pub type QuantumBit = ColumnVector>; -pub type QuantumGate = (&'static str, Matrix>); +pub type QuantumState = Matrix>; +pub type QuantumGate = (&'static str, QuantumState); #[macro_export] macro_rules! count { @@ -41,6 +42,7 @@ pub struct ClassicalRegister { bits: Vec, } +#[derive(Clone)] pub struct QuantumRegister { state: ColumnVector>, qubits: Vec, @@ -101,6 +103,10 @@ impl QuantumRegister { self.state = ColumnVector::from_matrix(&new_result); } + pub fn new(count: usize) -> QuantumRegister { + QuantumRegister::from(&mut vec![QuantumBit::state_0(); count]) + } + pub fn from(bits: &mut [QuantumBit]) -> QuantumRegister { let mut register = QuantumRegister { qubits: bits.to_vec(), @@ -111,10 +117,6 @@ impl QuantumRegister { register } - pub fn measure(&self, classical_register: &mut ClassicalRegister) { - classical_register.set_bits(self.qubits.iter().map(|qubit| qubit.measure()).collect()); - } - pub fn get_bits(&self) -> Vec { self.qubits.clone() } @@ -122,10 +124,6 @@ impl QuantumRegister { pub fn get_state(&self) -> ColumnVector> { self.state.clone() } - - pub fn apply(&self, gate: &QuantumGate) -> QuantumBit { - self.state.mul_matrix(&gate.1).unwrap() - } } impl ops::Index for QuantumRegister { diff --git a/libpsi-core/src/core/runtime.rs b/libpsi-core/src/core/runtime.rs index 0937f3c..19ac191 100644 --- a/libpsi-core/src/core/runtime.rs +++ b/libpsi-core/src/core/runtime.rs @@ -1,15 +1,15 @@ -use super::{ClassicalRegister, QuantumBit, QuantumCircuit}; +use super::{ClassicalRegister, QuantumCircuit, QuantumRegister}; #[allow(unused)] -pub struct ExecutationData { - pub quantum_states: Vec, +pub struct ExecutionData { + pub quantum_register: QuantumRegister, pub classical_states: ClassicalRegister, } -impl ExecutationData { - pub fn new(quantum_states: Vec, classical_states: ClassicalRegister) -> Self { - ExecutationData { - quantum_states, +impl ExecutionData { + pub fn new(quantum_register: QuantumRegister, classical_states: ClassicalRegister) -> Self { + ExecutionData { + quantum_register, classical_states, } } @@ -21,5 +21,5 @@ pub trait RuntimeBase { pub trait Runtime<'a, T: RuntimeBase = Self> { fn new(circuit: &'a QuantumCircuit) -> Self; - fn execute(&self, repeat: usize) -> Vec; + fn execute(&self, repeat: usize) -> Vec; } diff --git a/libpsi-core/src/maths/matrix.rs b/libpsi-core/src/maths/matrix.rs index 74857d1..636df08 100644 --- a/libpsi-core/src/maths/matrix.rs +++ b/libpsi-core/src/maths/matrix.rs @@ -174,7 +174,7 @@ impl fmt::Display for Matrix { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let max_width = (0..self.rows) .flat_map(|i| (0..self.cols).map(move |j| self.get(i, j))) - .map(|x| format!("{:.2}", x).split('.').next().unwrap().len()); + .map(|x| format!("{:.2}", x).split('.').next().unwrap().len()) .max() .unwrap_or(0); diff --git a/libpsi-core/src/runtimes/basic_rt.rs b/libpsi-core/src/runtimes/basic_rt.rs index 5cc1535..20befba 100644 --- a/libpsi-core/src/runtimes/basic_rt.rs +++ b/libpsi-core/src/runtimes/basic_rt.rs @@ -1,7 +1,4 @@ -use crate::{ - ColumnVector, Complex, ExecutationData, Numeric, QuantumBit, QuantumCircuit, QuantumRegister, - Runtime, RuntimeBase, Vector, -}; +use crate::{ExecutionData, QuantumCircuit, Runtime, RuntimeBase}; pub struct BasicRT<'a> { circuit: &'a QuantumCircuit, @@ -13,98 +10,23 @@ impl<'a> RuntimeBase for BasicRT<'a> { } } -impl<'a> BasicRT<'a> { - fn calculate_state(state: &ColumnVector>, n: usize) -> QuantumBit { - let num_states = 1 << n; - let half_states = num_states >> 1; - - let mut alpha = Complex::zero(); - let mut beta = Complex::zero(); - - for i in 0..num_states { - if i < half_states { - alpha += state[i]; - } else { - beta += state[i]; - } - } - - QuantumBit::new(vec![alpha, beta]) - } - - fn calculate_probabilities(state: &ColumnVector>, n: usize) -> (f64, f64) { - let num_states = 1 << n; - let half_states = num_states >> 1; - - let mut state_0 = 0.0; - let mut state_1 = 0.0; - - for i in 0..num_states { - let prob = state[i].norm() * state[i].norm(); - if i < half_states { - state_0 += prob; - } else { - state_1 += prob; - } - } - - (state_0, state_1) - } -} - impl<'a> Runtime<'a> for BasicRT<'a> { fn new(circuit: &'a QuantumCircuit) -> BasicRT { BasicRT { circuit } } - fn execute(&self, repeat: usize) -> Vec { - let mut result: Vec = Vec::with_capacity(repeat); + fn execute(&self, repeat: usize) -> Vec { + let mut result: Vec = Vec::with_capacity(repeat); for _ in 0..repeat { - let mut executation_data = ExecutationData::new( - self.circuit.get_quantum_bits(), + let executation_data = ExecutionData::new( + self.circuit.get_quantum_register(), self.circuit.get_classical_registers(), ); for instruction in self.circuit.get_instructions() { - let mut control_bits: Vec = Vec::new(); - let mut target_bits: Vec = Vec::new(); - let mut quantum_bits: Vec = Vec::new(); - - for index in instruction.control_indices.clone() { - control_bits.push(executation_data.quantum_states.clone()[index].clone()); - quantum_bits.push(executation_data.quantum_states.clone()[index].clone()); - } - - for index in instruction.target_indices.clone() { - target_bits.push(executation_data.quantum_states.clone()[index].clone()); - quantum_bits.push(executation_data.quantum_states.clone()[index].clone()); - } - - if control_bits.len() > 0 { - let control_register = QuantumRegister::from(&mut control_bits); - let control_register_state_vector = control_register.get_state(); - let (control_register_state_0, control_register_state_1) = - BasicRT::calculate_probabilities( - &control_register_state_vector, - control_register.get_bits().len(), - ); - - if control_register_state_0 > control_register_state_1 { - continue; - } - } - - let target_register = QuantumRegister::from(&mut quantum_bits); - let target_state_vector = target_register.apply(&instruction.gate); - let target_state = - BasicRT::calculate_state(&target_state_vector, quantum_bits.len()); - executation_data.quantum_states[instruction.target_indices.clone()[0]] = - target_state; + println!("{} on q{}", instruction.gate.0, instruction.target_bit); } - let final_quantum_register = - QuantumRegister::from(&mut executation_data.quantum_states.clone()); - final_quantum_register.measure(&mut executation_data.classical_states); result.push(executation_data); } result -- cgit v1.3