use crate::execution::ExecutionError;
use thiserror::Error;
const N_LOGICAL: usize = 512;
const M_MEASURED: usize = 128;
const INDIRECT_ZERO_FILL: usize = 1024;
const DEFAULT_ITERATIONS: usize = 768;
const ABSOLUTE_ITERATIONS: usize = 2048;
const DEFAULT_BYTES: usize = 512 * 1024 * 1024;
const DEFAULT_RECONSTRUCTION_WORK: u128 = 35_000_000_000;
#[derive(Clone, Debug, PartialEq)]
pub struct IstInput {
nlogical: usize,
f2_points: usize,
cartesian_fields: usize,
measured_indices: Vec<usize>,
components: Vec<f64>,
}
impl IstInput {
pub fn new(
f2_points: usize,
cartesian_fields: usize,
measured_indices: Vec<usize>,
components: Vec<f64>,
) -> Result<Self, IstError> {
if measured_indices.len() != M_MEASURED {
return Err(IstError::InvalidInput);
}
Self::with_grid(
N_LOGICAL,
f2_points,
cartesian_fields,
measured_indices,
components,
)
}
pub fn with_grid(
nlogical: usize,
f2_points: usize,
cartesian_fields: usize,
measured_indices: Vec<usize>,
components: Vec<f64>,
) -> Result<Self, IstError> {
if nlogical == 0
|| f2_points == 0
|| !matches!(cartesian_fields, 1 | 2)
|| measured_indices.is_empty()
|| measured_indices.len() > nlogical
{
return Err(IstError::InvalidInput);
}
let mut sorted = measured_indices.clone();
sorted.sort_unstable();
if sorted.last().is_some_and(|v| *v >= nlogical) || sorted.windows(2).any(|v| v[0] == v[1])
{
return Err(IstError::InvalidInput);
}
let expected = measured_indices
.len()
.checked_mul(f2_points)
.and_then(|value| value.checked_mul(cartesian_fields))
.and_then(|value| value.checked_mul(2))
.ok_or(IstError::SizeOverflow)?;
if components.len() != expected || components.iter().any(|value| !value.is_finite()) {
return Err(IstError::InvalidInput);
}
Ok(Self {
nlogical,
f2_points,
cartesian_fields,
measured_indices,
components,
})
}
pub fn nlogical(&self) -> usize {
self.nlogical
}
pub fn f2_points(&self) -> usize {
self.f2_points
}
pub fn cartesian_fields(&self) -> usize {
self.cartesian_fields
}
pub fn measured_indices(&self) -> &[usize] {
&self.measured_indices
}
pub fn components(&self) -> &[f64] {
&self.components
}
fn complex_len(&self) -> usize {
self.components.len() / 2
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct IstOutput {
nlogical: usize,
f2_points: usize,
cartesian_fields: usize,
components: Vec<f64>,
iterations: usize,
estimated_work: u128,
noise_standard_deviation: f64,
columns: Vec<ColumnState>,
}
impl IstOutput {
pub fn nlogical(&self) -> usize {
self.nlogical
}
pub fn f2_points(&self) -> usize {
self.f2_points
}
pub fn cartesian_fields(&self) -> usize {
self.cartesian_fields
}
pub fn components(&self) -> &[f64] {
&self.components
}
pub fn iterations(&self) -> usize {
self.iterations
}
pub fn estimated_work(&self) -> u128 {
self.estimated_work
}
pub fn noise_standard_deviation(&self) -> f64 {
self.noise_standard_deviation
}
pub fn final_threshold(&self) -> f64 {
self.columns
.iter()
.map(|column| column.floor)
.fold(0.0, f64::max)
}
pub fn relative_change(&self) -> f64 {
self.columns
.iter()
.map(|column| column.relative_change)
.fold(0.0, f64::max)
}
pub fn column_final_threshold(&self, column: usize) -> Option<f64> {
self.columns.get(column).map(|state| state.floor)
}
pub fn column_relative_change(&self, column: usize) -> Option<f64> {
self.columns.get(column).map(|state| state.relative_change)
}
pub fn column_iterations(&self, column: usize) -> Option<usize> {
self.columns.get(column).map(|state| state.iterations)
}
pub fn measured_relative_residual(&self) -> f64 {
0.0
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct IstOptions {
max_output_bytes: usize,
max_working_bytes: usize,
max_iterations: usize,
max_reconstruction_work: u128,
noise_standard_deviation: Option<f64>,
}
impl IstOptions {
pub fn new() -> Self {
Self::default()
}
pub fn noise_standard_deviation(mut self, sigma: f64) -> Result<Self, IstError> {
if !sigma.is_finite() || sigma < 0.0 {
return Err(IstError::InvalidOptions);
}
self.noise_standard_deviation = Some(sigma);
Ok(self)
}
pub fn noiseless(mut self) -> Self {
self.noise_standard_deviation = Some(0.0);
self
}
pub fn max_output_bytes(mut self, bytes: usize) -> Self {
self.max_output_bytes = bytes;
self
}
pub fn max_working_bytes(mut self, bytes: usize) -> Self {
self.max_working_bytes = bytes;
self
}
pub fn max_iterations(mut self, iterations: usize) -> Result<Self, IstError> {
if iterations == 0 || iterations > ABSOLUTE_ITERATIONS {
return Err(IstError::InvalidOptions);
}
self.max_iterations = iterations;
Ok(self)
}
pub fn max_reconstruction_work(mut self, work: u128) -> Self {
self.max_reconstruction_work = work;
self
}
pub fn output_bytes(self) -> usize {
self.max_output_bytes
}
pub fn working_bytes(self) -> usize {
self.max_working_bytes
}
pub fn iterations(self) -> usize {
self.max_iterations
}
pub fn reconstruction_work(self) -> u128 {
self.max_reconstruction_work
}
}
impl Default for IstOptions {
fn default() -> Self {
Self {
max_output_bytes: DEFAULT_BYTES,
max_working_bytes: DEFAULT_BYTES,
max_iterations: DEFAULT_ITERATIONS,
max_reconstruction_work: DEFAULT_RECONSTRUCTION_WORK,
noise_standard_deviation: None,
}
}
}
#[non_exhaustive]
#[derive(Clone, Debug, Error, Eq, PartialEq)]
pub enum IstError {
#[error("IST cancelled")]
Cancelled,
#[error("IST input does not satisfy the selected grid/component contract")]
InvalidInput,
#[error("IST options are invalid")]
InvalidOptions,
#[error("IST requires an independent noise standard deviation or a noiseless assertion")]
NoiseEstimateRequired,
#[error("IST input has no recoverable signal")]
NoRecoverableSignal,
#[error("IST reconstruction did not converge")]
DidNotConverge,
#[error("IST output exceeds max_output_bytes")]
OutputLimit,
#[error("IST working set exceeds max_working_bytes")]
WorkingLimit,
#[error("IST reconstruction exceeds its work limit")]
WorkLimit,
#[error("IST size computation overflow")]
SizeOverflow,
#[error("IST allocation failed")]
AllocationFailure,
#[error("IST numerical invariant was violated")]
NumericalInvariantViolation,
#[error("IST retained measured value changed bits")]
RetainedBitsMismatch,
}
struct MemoryEstimate {
output_bytes: usize,
peak_working_bytes: usize,
}
fn validate_options(options: IstOptions) -> Result<(), IstError> {
if options.max_iterations == 0 || options.max_iterations > ABSOLUTE_ITERATIONS {
return Err(IstError::InvalidOptions);
}
Ok(())
}
#[derive(Clone, Debug, PartialEq)]
struct ColumnState {
lambda: f64,
floor: f64,
relative_change: f64,
converged_at_floor: usize,
iterations: usize,
converged: bool,
momentum_t: f64,
}
impl From<ExecutionError> for IstError {
fn from(error: ExecutionError) -> Self {
match error {
ExecutionError::Cancelled => Self::Cancelled,
ExecutionError::WorkLimit => Self::WorkLimit,
ExecutionError::SizeOverflow => Self::SizeOverflow,
}
}
}
mod iteration;
mod reconstruction;
pub(super) mod resources;
mod versions;
pub use versions::{GeneralGridPhaseCovariantGroupRetainedIstV1, PhaseCovariantGroupRetainedIstV1};