mod bridge;
mod runtime;
use runtime::Mode;
pub mod execution;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use super::finite_leaf::{
CheckedSerializedUnitaryLeaf, UnitaryBoundary, check_serialized_unitary, check_unitary,
};
use super::json::Value;
use super::{Error, Result, contract_error};
use crate::contract::exact::{Budget, Exact, Matrix};
use crate::contract::{BasisType, ContractError, DEFAULT_EXACT_WORK};
use crate::ir::{BasisShape, QuantumPort, TokenId, WireId};
#[derive(Clone, Debug)]
pub struct Kernel {
executable: PathBuf,
}
#[derive(Debug)]
pub struct Reconstructed {
payload: Arc<[u8]>,
leaves: Vec<(usize, CheckedSerializedUnitaryLeaf)>,
structural_work: usize,
exact_work: usize,
}
impl Reconstructed {
fn new(
payload: &[u8],
leaves: Vec<(usize, CheckedSerializedUnitaryLeaf)>,
structural_work: usize,
budget: &Budget,
) -> Self {
Self {
payload: Arc::from(payload),
leaves,
structural_work,
exact_work: DEFAULT_EXACT_WORK - budget.remaining(),
}
}
pub fn payload(&self) -> &[u8] {
&self.payload
}
pub fn leaves(&self) -> &[(usize, CheckedSerializedUnitaryLeaf)] {
&self.leaves
}
pub fn structural_work(&self) -> usize {
self.structural_work
}
pub fn exact_work(&self) -> usize {
self.exact_work
}
}
impl Kernel {
pub fn new(executable: impl Into<PathBuf>) -> Self {
Self {
executable: executable.into(),
}
}
pub fn executable(&self) -> &Path {
&self.executable
}
pub fn inspect(&self, payload: &[u8]) -> Result<Reconstructed> {
let decoded = bridge::decode(payload)?;
let response = runtime::check(&self.executable, decoded.bridge, Mode::Inspect)?;
let mut budget = Budget::new(DEFAULT_EXACT_WORK);
let leaves = reconstruct(&decoded.value, response.indices, &mut budget)?;
Ok(Reconstructed::new(payload, leaves, response.work, &budget))
}
}
fn reconstruct(
value: &Value,
indices: Vec<usize>,
budget: &mut Budget,
) -> Result<Vec<(usize, CheckedSerializedUnitaryLeaf)>> {
let proofs = value.field("proofs")?.array()?;
let definitions = value.field("definitions")?.array()?;
let meanings = value.field("meanings")?.array()?;
let mut leaves = Vec::with_capacity(indices.len());
let mut seen = vec![false; proofs.len()];
for index in indices {
let proof = proofs
.get(index)
.ok_or_else(|| Error::format("runtime returned an invalid proof index"))?;
if seen[index] || proof.field("rule")?.field("tag")?.text()? != "finite" {
return Err(Error::format(
"runtime returned duplicate or non-finite proof index",
));
}
seen[index] = true;
let definition = &definitions[bridge::number(proof.field("implementation")?)? as usize];
let meaning = &meanings[bridge::number(proof.field("meaning")?)? as usize];
let db = definition.field("body")?;
let mb = meaning.field("body")?;
if db.field("tag")?.text()? != "leaf" || mb.field("tag")?.text()? != "finite" {
return Err(Error::new(
"contract",
"finite request does not name actual finite bodies",
));
}
let program = db.field("program")?.text()?.as_bytes();
let description = mb.field("description")?.text()?.as_bytes();
let boundary = boundary(definition.field("interface")?)?;
let checked = check_serialized_unitary(program, &boundary, description, budget)?;
leaves.push((index, checked));
}
for (index, proof) in proofs.iter().enumerate() {
if proof.field("rule")?.field("tag")?.text()? == "finite" && !seen[index] {
return Err(Error::format(
"runtime omitted a finite reconstruction obligation",
));
}
}
Ok(leaves)
}
#[derive(Debug)]
pub struct CheckedRequest {
reconstruction: Reconstructed,
request: Arc<[u8]>,
}
impl CheckedRequest {
pub fn reconstruction(&self) -> &Reconstructed {
&self.reconstruction
}
pub fn request(&self) -> &[u8] {
&self.request
}
}
impl Kernel {
pub fn check_against(&self, payload: &[u8], request: &[u8]) -> Result<CheckedRequest> {
let decoded = bridge::decode_request(payload, request)?;
let mode = if decoded.fourier_width.is_some() {
Mode::Fourier
} else {
Mode::Request
};
let response = runtime::check(&self.executable, decoded.bridge, mode)?;
let mut budget = Budget::new(DEFAULT_EXACT_WORK);
let leaves = reconstruct(&decoded.actual, response.indices, &mut budget)?;
if let Some(width) = decoded.fourier_width {
reconstruct_hadamards(&decoded.actual, width, response.pairs, &mut budget)?;
} else {
reconstruct_pairs(
&decoded.actual,
&decoded.request,
&decoded.pairs,
response.pairs,
&mut budget,
)?;
}
Ok(CheckedRequest {
reconstruction: Reconstructed::new(payload, leaves, response.work, &budget),
request: Arc::from(request),
})
}
}
fn reconstruct_pairs(
actual: &Value,
required: &Value,
pairs: &[(usize, usize)],
indices: Vec<usize>,
budget: &mut Budget,
) -> Result<()> {
let actual = actual.field("meanings")?.array()?;
let required = required.field("meanings")?.array()?;
let mut seen = vec![false; pairs.len()];
for index in indices {
let &(a, r) = pairs
.get(index)
.ok_or_else(|| Error::format("runtime returned invalid meaning pair index"))?;
if seen[index] {
return Err(Error::format(
"runtime returned duplicate meaning pair index",
));
}
seen[index] = true;
let a = actual[a].field("body")?;
let r = required[r].field("body")?;
if a.field("tag")?.text()? != "finite" || r.field("tag")?.text()? != "finite" {
return Err(Error::format("runtime returned non-finite meaning pair"));
}
let a = super::finite_matrix::decode(a.field("description")?.text()?.as_bytes(), budget)?;
let r = super::finite_matrix::decode(r.field("description")?.text()?.as_bytes(), budget)?;
budget
.charge(a.entries().len())
.map_err(ContractError::from)
.map_err(contract_error)?;
if a != r {
return Err(Error::new(
"contract",
"finite meaning differs from independently requested matrix",
));
}
}
for (i, &(a, r)) in pairs.iter().enumerate() {
if actual[a].field("body")?.field("tag")?.text()? == "finite"
&& required[r].field("body")?.field("tag")?.text()? == "finite"
&& !seen[i]
{
return Err(Error::format(
"runtime omitted finite meaning equality obligation",
));
}
}
Ok(())
}
#[derive(Debug)]
pub struct CheckedInstrument {
reconstruction: Reconstructed,
request: Arc<[u8]>,
}
impl CheckedInstrument {
pub fn reconstruction(&self) -> &Reconstructed {
&self.reconstruction
}
pub fn request(&self) -> &[u8] {
&self.request
}
}
impl Kernel {
pub fn check_instrument(&self, payload: &[u8], request: &[u8]) -> Result<CheckedInstrument> {
let decoded = bridge::decode_instrument(payload, request)?;
let response = runtime::check(&self.executable, decoded.bridge, Mode::Instrument)?;
let mut budget = Budget::new(DEFAULT_EXACT_WORK);
let leaves = reconstruct(&decoded.pure.actual, response.indices, &mut budget)?;
reconstruct_pairs(
&decoded.pure.actual,
&decoded.pure.request,
&decoded.pure.pairs,
response.pairs,
&mut budget,
)?;
Ok(CheckedInstrument {
reconstruction: Reconstructed::new(payload, leaves, response.work, &budget),
request: Arc::from(request),
})
}
pub fn check_qpe_instrument(
&self,
payload: &[u8],
request: &[u8],
candidate: &[u8],
) -> Result<CheckedQpeInstrument> {
let decoded = bridge::decode_qpe_instrument(payload, request, candidate)?;
let response = runtime::check(&self.executable, decoded.bridge, Mode::QpeInstrument)?;
let mut budget = Budget::new(DEFAULT_EXACT_WORK);
let leaves = reconstruct(&decoded.provider.actual, response.indices, &mut budget)?;
reconstruct_pairs(
&decoded.provider.actual,
&decoded.provider.request,
&decoded.provider.pairs,
response.pairs,
&mut budget,
)?;
let returned: std::collections::BTreeSet<_> = response.hadamards.iter().copied().collect();
if returned.len() != response.hadamards.len() || returned != decoded.hadamards {
return Err(Error::format(
"runtime omitted, duplicated or substituted QPE Hadamard obligations",
));
}
for index in response.hadamards {
reconstruct_hadamards(&decoded.provider.actual, 1, vec![index], &mut budget)?;
}
Ok(CheckedQpeInstrument {
instrument: CheckedInstrument {
reconstruction: Reconstructed::new(payload, leaves, response.work, &budget),
request: Arc::from(request),
},
candidate: Arc::from(candidate),
})
}
}
#[derive(Debug)]
pub struct CheckedQpeInstrument {
instrument: CheckedInstrument,
candidate: Arc<[u8]>,
}
impl CheckedQpeInstrument {
pub fn instrument(&self) -> &CheckedInstrument {
&self.instrument
}
pub fn candidate(&self) -> &[u8] {
&self.candidate
}
}
fn reconstruct_hadamards(
value: &Value,
width: usize,
indices: Vec<usize>,
budget: &mut Budget,
) -> Result<()> {
if !(1..=8).contains(&width) || indices.len() != width {
return Err(Error::format(
"runtime omitted Fourier Hadamard obligations",
));
}
let r = Exact::inv_sqrt2();
let negative = r
.neg()
.map_err(ContractError::from)
.map_err(contract_error)?;
let expected = Matrix::new(2, 2, vec![r, r, r, negative])
.map_err(ContractError::from)
.map_err(contract_error)?;
let definitions = value.field("definitions")?.array()?;
let mut seen = vec![false; definitions.len()];
for index in indices {
let d = definitions
.get(index)
.ok_or_else(|| Error::format("runtime returned invalid H definition index"))?;
if seen[index] || d.field("body")?.field("tag")?.text()? != "leaf" {
return Err(Error::format(
"runtime returned duplicate or non-leaf H index",
));
}
seen[index] = true;
let program = d.field("body")?.field("program")?.text()?.as_bytes();
check_unitary(
program,
&boundary(d.field("interface")?)?,
&expected,
budget,
)?;
}
Ok(())
}
fn legacy(value: &Value) -> Result<BasisType> {
let mut stack = Vec::new();
for atom in value.array()?.iter().rev() {
match atom.field("tag")?.text()? {
"unit" => stack.push(BasisType::Unit),
"bit" => stack.push(BasisType::Bit),
"tuple" => {
let arity = bridge::number(atom.field("arity")?)? as usize;
if arity < 2 || arity > stack.len() {
return Err(Error::format("invalid finite type tree"));
}
let fields = (0..arity).map(|_| stack.pop().unwrap()).collect();
stack.push(BasisType::Tuple(fields));
}
_ => {
return Err(Error::new(
"contract",
"finite boundary requires an explicit legacy type",
));
}
}
}
if stack.len() != 1 {
return Err(Error::format(
"finite boundary is not one complete type tree",
));
}
Ok(stack.pop().unwrap())
}
fn boundary(value: &Value) -> Result<UnitaryBoundary> {
let port = |side: &Value| -> Result<(BasisType, QuantumPort)> {
let ports = side.field("quantum")?.array()?;
if ports.len() != 1 || !side.field("classical")?.array()?.is_empty() {
return Err(Error::new(
"contract",
"finite unitary request requires unary quantum endpoints",
));
}
let p = &ports[0];
let ty = legacy(p.field("basis")?)?;
let bits = ty.bits().map_err(contract_error)?;
let wires = p
.field("axes")?
.array()?
.iter()
.map(|v| bridge::number(v).map(WireId))
.collect::<Result<_>>()?;
Ok((
ty,
QuantumPort {
token: TokenId(bridge::number(p.field("owner")?)?),
wires,
shape: BasisShape { bits: bits as u8 },
},
))
};
let (input_type, input) = port(value.field("inputs")?)?;
let (output_type, output) = port(value.field("outputs")?)?;
if input_type != output_type {
return Err(Error::new("contract", "finite endpoint type trees differ"));
}
UnitaryBoundary::new(input_type, input, output)
}