use super::sequents::Sequent;
use crate::limits::Limits;
use crate::linear::fragment::Order;
use crate::linear::nets::{Criterion, MellStructure, Parts, Placed, ProofStructure, VertexId};
use crate::linear::occurrences::{Forest, OccId};
use crate::wire::{self, Readable};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone, Debug, Serialize, Deserialize)]
struct Net {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
sequent: Sequent,
mix: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
order: Option<OrderForm>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
cuts: Vec<(u32, u32)>,
links: Vec<(u32, u32)>,
#[serde(default, skip_serializing)]
vertices: Option<serde::de::IgnoredAny>,
}
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
enum OrderForm {
Commutative,
Cyclic,
}
impl From<OrderForm> for Order {
fn from(form: OrderForm) -> Self {
match form {
OrderForm::Commutative => Order::Commutative,
OrderForm::Cyclic => Order::Cyclic,
}
}
}
impl Serialize for ProofStructure {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
form(self).serialize(serializer)
}
}
fn form(net: &ProofStructure) -> Net {
let order = match net.criterion().order {
Order::Commutative => None,
Order::Cyclic => Some(OrderForm::Cyclic),
};
let pair = |&(x, y): &(VertexId, VertexId)| (x.get(), y.get());
Net {
version: Some(if order.is_some() {
wire::level_of_sequent(net.sequent()).max(2)
} else {
wire::level_of_sequent(net.sequent())
}),
sequent: Sequent::from(net.sequent()),
mix: net.criterion().mix,
order,
vertices: None,
cuts: net.cuts().iter().map(pair).collect(),
links: net.links().iter().map(pair).collect(),
}
}
impl<'a> Deserialize<'a> for ProofStructure {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for ProofStructure {}
impl Readable for ProofStructure {
const FORM: &'static str = "proof structure";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
let net = Net::deserialize(deserializer)?;
if net.vertices.is_some() {
return Err(serde::de::Error::custom(
"a proof structure with boxes, whose links name its vertices: read it as one",
));
}
let build = || {
let sequent = crate::linear::Sequent::try_from(net.sequent)?;
let forest = Forest::from_owned(sequent, limits)?;
let pair = |&(x, y): &(u32, u32)| (VertexId::new(x), VertexId::new(y));
let links: Vec<(VertexId, VertexId)> = net.links.iter().map(pair).collect();
let cuts: Vec<(VertexId, VertexId)> = net.cuts.iter().map(pair).collect();
let criterion = Criterion {
mix: net.mix,
order: net.order.map_or(Order::Commutative, Order::from),
};
ProofStructure::with_cuts(forest, criterion, &cuts, &links)
};
build().map_err(wire::fail)
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct Boxed {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
sequent: Sequent,
mix: bool,
vertices: Vec<(u32, Option<u32>, Option<u32>)>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
cuts: Vec<(u32, u32)>,
links: Vec<(u32, u32)>,
weakenings: Vec<(u32, u32)>,
}
impl Serialize for MellStructure {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
boxed(self).serialize(serializer)
}
}
fn boxed(net: &MellStructure) -> Boxed {
let parts = net.parts();
let pair = |&(x, y): &(VertexId, VertexId)| (x.get(), y.get());
Boxed {
version: Some(wire::BOXES.max(wire::level_of_sequent(net.forest().sequent()))),
sequent: Sequent::from(net.forest().sequent()),
mix: net.criterion().mix,
vertices: parts
.vertices
.iter()
.map(|p| {
(
p.occurrence.get(),
p.parent.map(VertexId::get),
p.inside.map(VertexId::get),
)
})
.collect(),
cuts: parts.cuts.iter().map(pair).collect(),
links: parts.links.iter().map(pair).collect(),
weakenings: parts.weakenings.iter().map(pair).collect(),
}
}
#[derive(Serialize)]
struct StepForm {
cut: (u32, u32),
case: crate::linear::proofs::cut::Case,
#[serde(skip_serializing_if = "Option::is_none")]
above: Option<u32>,
}
#[derive(Serialize)]
struct EliminationForm<'a, F> {
version: u32,
net: F,
steps: Vec<StepForm>,
end: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
reason: Option<&'a crate::Error>,
}
fn record<S: Serializer, F: Serialize>(
serializer: S,
net: F,
version: u32,
steps: &[crate::linear::nets::cut::Step],
end: &crate::linear::proofs::cut::End,
) -> Result<S::Ok, S::Error> {
use crate::linear::proofs::cut::End;
let reason = match end {
End::CutFree => None,
End::Refused(refusal) => Some(crate::Error::Refused(refusal.clone())),
};
EliminationForm {
version,
net,
steps: steps
.iter()
.map(|step| StepForm {
cut: (step.cut.0.get(), step.cut.1.get()),
case: step.case,
above: step.above.map(VertexId::get),
})
.collect(),
end: if reason.is_some() {
"refused"
} else {
"cut_free"
},
reason: reason.as_ref(),
}
.serialize(serializer)
}
impl Serialize for crate::linear::nets::cut::Elimination<ProofStructure> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut net = form(&self.net);
let version = net.version.take().unwrap_or(wire::BASE);
record(serializer, net, version, &self.steps, &self.end)
}
}
impl Serialize for crate::linear::nets::cut::Elimination<MellStructure> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut net = boxed(&self.net);
let version = net.version.take().unwrap_or(wire::BOXES);
record(serializer, net, version, &self.steps, &self.end)
}
}
impl<'a> Deserialize<'a> for MellStructure {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for MellStructure {}
impl Readable for MellStructure {
const FORM: &'static str = "proof structure with boxes";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
let boxed = Boxed::deserialize(deserializer)?;
let build = || {
let sequent = crate::linear::Sequent::try_from(boxed.sequent)?;
let forest = Forest::from_owned(sequent, limits)?;
let pair = |&(x, y): &(u32, u32)| (VertexId::new(x), VertexId::new(y));
let parts = Parts {
vertices: boxed
.vertices
.iter()
.map(|&(o, p, b)| match p {
Some(p) => {
Placed::new(OccId::new(o), VertexId::new(p), b.map(VertexId::new))
}
None => Placed::cut(OccId::new(o), b.map(VertexId::new)),
})
.collect(),
cuts: boxed.cuts.iter().map(pair).collect(),
links: boxed.links.iter().map(pair).collect(),
weakenings: boxed.weakenings.iter().map(pair).collect(),
};
let criterion = Criterion {
mix: boxed.mix,
order: Order::Commutative,
};
MellStructure::from_parts(forest, criterion, &parts, limits)
};
build().map_err(wire::fail)
}
}