faultscope-core 0.2.12

Python-independent circuit, DEM, sampling, and decoder primitives for FaultScope
Documentation
use std::collections::HashMap;

use crate::program::{ExpandedOperation, ExpandedProgram};
use crate::{Detector, LogicalObservable, NpError, NpResult, SamplerObservable};

#[derive(Debug, Clone, PartialEq)]
pub(super) struct IndexedDemDetector {
    pub(super) id: i64,
    pub(super) measurement_indices: Vec<usize>,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct IndexedDemObservable {
    pub(super) id: i64,
    pub(super) measurement_indices: Vec<usize>,
    pub(super) pauli_qubits: Vec<usize>,
    pub(super) pauli: String,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct DemMeasurementPlan {
    pub(super) measurement_count: usize,
    pub(super) measurement_index_by_id: Vec<Option<usize>>,
    pub(super) detectors: Vec<IndexedDemDetector>,
    pub(super) observables: Vec<IndexedDemObservable>,
}

struct DetectorMeasurementIds {
    id: i64,
    measurement_ids: Vec<usize>,
}

pub(super) fn compile_dem_measurement_plan(
    program: &ExpandedProgram,
    detectors: &[Detector],
    observables: &[LogicalObservable],
) -> NpResult<DemMeasurementPlan> {
    compile_dem_measurement_plan_with_optional_declarations(
        program,
        Some(detectors),
        Some(observables),
    )
}

pub(super) fn compile_dem_measurement_plan_with_optional_declarations(
    program: &ExpandedProgram,
    detectors: Option<&[Detector]>,
    observables: Option<&[LogicalObservable]>,
) -> NpResult<DemMeasurementPlan> {
    let measurement_id_by_key = (detectors.is_some() || observables.is_some()).then(|| {
        program
            .measurement_keys
            .iter()
            .enumerate()
            .map(|(measurement_id, key)| (key.as_str(), measurement_id))
            .collect::<HashMap<_, _>>()
    });
    let detectors = match detectors {
        Some(detectors) => detectors
            .iter()
            .map(|detector| {
                Ok(DetectorMeasurementIds {
                    id: detector.id,
                    measurement_ids: measurement_ids_for_keys(
                        measurement_id_by_key
                            .as_ref()
                            .expect("explicit declarations require a key index"),
                        &detector.measurement_keys,
                    )?,
                })
            })
            .collect::<NpResult<Vec<_>>>()?,
        None => inferred_detector_measurement_ids(program),
    };
    let observables = match observables {
        Some(observables) => observables
            .iter()
            .map(|observable| {
                Ok(SamplerObservable {
                    id: observable.id,
                    measurement_ids: measurement_ids_for_keys(
                        measurement_id_by_key
                            .as_ref()
                            .expect("explicit declarations require a key index"),
                        &observable.measurement_keys,
                    )?,
                    pauli_qubits: observable.pauli_qubits.clone(),
                    pauli: observable.pauli.clone(),
                })
            })
            .collect::<NpResult<Vec<_>>>()?,
        None => inferred_observable_measurement_ids(program),
    };

    Ok(compile_dem_measurement_plan_from_ids(
        program,
        detectors,
        observables,
    ))
}

fn inferred_detector_measurement_ids(program: &ExpandedProgram) -> Vec<DetectorMeasurementIds> {
    let mut detectors = Vec::new();
    for operation in &program.operations {
        if let ExpandedOperation::Detector {
            detector_id,
            measurement_ids,
        } = operation
        {
            detectors.push(DetectorMeasurementIds {
                id: *detector_id,
                measurement_ids: measurement_ids.clone(),
            });
        }
    }
    detectors
}

fn inferred_observable_measurement_ids(program: &ExpandedProgram) -> Vec<SamplerObservable> {
    let mut observables_by_id = HashMap::<i64, Vec<usize>>::new();
    for operation in &program.operations {
        if let ExpandedOperation::ObservableInclude {
            observable_id,
            measurement_ids,
        } = operation
        {
            observables_by_id
                .entry(*observable_id)
                .or_default()
                .extend(measurement_ids);
        }
    }
    observables_by_id
        .into_iter()
        .map(|(id, measurement_ids)| SamplerObservable {
            id,
            measurement_ids,
            pauli_qubits: Vec::new(),
            pauli: String::new(),
        })
        .collect()
}

fn compile_dem_measurement_plan_from_ids(
    program: &ExpandedProgram,
    detectors: Vec<DetectorMeasurementIds>,
    observables: Vec<SamplerObservable>,
) -> DemMeasurementPlan {
    let mut required_measurements = vec![false; program.measurement_keys.len()];
    for measurement_id in detectors
        .iter()
        .flat_map(|detector| &detector.measurement_ids)
        .chain(
            observables
                .iter()
                .flat_map(|observable| &observable.measurement_ids),
        )
    {
        required_measurements[*measurement_id] = true;
    }

    let mut measurement_index_by_id = vec![None; program.measurement_keys.len()];
    let mut indexed_measurement_count = 0usize;

    for (measurement_id, required) in required_measurements.into_iter().enumerate() {
        if required {
            measurement_index_by_id[measurement_id] = Some(indexed_measurement_count);
            indexed_measurement_count += 1;
        }
    }

    let mut indexed_detectors = detectors
        .into_iter()
        .map(|detector| IndexedDemDetector {
            id: detector.id,
            measurement_indices: measurement_indices_for_ids(
                &measurement_index_by_id,
                &detector.measurement_ids,
            ),
        })
        .collect::<Vec<_>>();
    indexed_detectors.sort_by_key(|detector| detector.id);

    let mut indexed_observables = observables
        .into_iter()
        .map(|observable| IndexedDemObservable {
            id: observable.id,
            measurement_indices: measurement_indices_for_ids(
                &measurement_index_by_id,
                &observable.measurement_ids,
            ),
            pauli_qubits: observable.pauli_qubits,
            pauli: observable.pauli,
        })
        .collect::<Vec<_>>();
    indexed_observables.sort_by_key(|observable| observable.id);

    DemMeasurementPlan {
        measurement_count: indexed_measurement_count,
        measurement_index_by_id,
        detectors: indexed_detectors,
        observables: indexed_observables,
    }
}

pub(super) fn optional_indexed_measurement(
    measurement_plan: &DemMeasurementPlan,
    measurement_id: usize,
) -> Option<usize> {
    measurement_plan
        .measurement_index_by_id
        .get(measurement_id)
        .and_then(|index| *index)
}

fn measurement_ids_for_keys(
    measurement_id_by_key: &HashMap<&str, usize>,
    keys: &[String],
) -> NpResult<Vec<usize>> {
    keys.iter()
        .map(|key| {
            measurement_id_by_key
                .get(key.as_str())
                .copied()
                .ok_or_else(|| NpError::new(format!("unknown measurement key {key:?}")))
        })
        .collect()
}

fn measurement_indices_for_ids(
    measurement_index_by_id: &[Option<usize>],
    measurement_ids: &[usize],
) -> Vec<usize> {
    measurement_ids
        .iter()
        .map(|measurement_id| {
            measurement_index_by_id[*measurement_id]
                .expect("required DEM measurement must have a dense index")
        })
        .collect()
}