1use super::sequents::Sequent;
5use crate::limits::Limits;
6use crate::linear::fragment::Order;
7use crate::linear::nets::{Criterion, MellStructure, Parts, Placed, ProofStructure, VertexId};
8use crate::linear::occurrences::{Forest, OccId};
9use crate::wire::{self, Readable};
10use serde::{Deserialize, Deserializer, Serialize, Serializer};
11
12#[derive(Clone, Debug, Serialize, Deserialize)]
18struct Net {
19 #[serde(
21 default,
22 skip_serializing_if = "Option::is_none",
23 deserialize_with = "wire::version"
24 )]
25 version: Option<u32>,
26 sequent: Sequent,
28 mix: bool,
30 #[serde(default, skip_serializing_if = "Option::is_none")]
33 order: Option<OrderForm>,
34 #[serde(default, skip_serializing_if = "Vec::is_empty")]
36 cuts: Vec<(u32, u32)>,
37 links: Vec<(u32, u32)>,
39 #[serde(default, skip_serializing)]
43 vertices: Option<serde::de::IgnoredAny>,
44}
45
46#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
48#[serde(rename_all = "lowercase")]
49enum OrderForm {
50 Commutative,
52 Cyclic,
54}
55
56impl From<OrderForm> for Order {
57 fn from(form: OrderForm) -> Self {
59 match form {
60 OrderForm::Commutative => Order::Commutative,
61 OrderForm::Cyclic => Order::Cyclic,
62 }
63 }
64}
65
66impl Serialize for ProofStructure {
67 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
70 form(self).serialize(serializer)
71 }
72}
73
74fn form(net: &ProofStructure) -> Net {
76 let order = match net.criterion().order {
77 Order::Commutative => None,
78 Order::Cyclic => Some(OrderForm::Cyclic),
79 };
80 let pair = |&(x, y): &(VertexId, VertexId)| (x.get(), y.get());
81 Net {
82 version: Some(if order.is_some() {
85 wire::level_of_sequent(net.sequent()).max(2)
86 } else {
87 wire::level_of_sequent(net.sequent())
88 }),
89 sequent: Sequent::from(net.sequent()),
90 mix: net.criterion().mix,
91 order,
92 vertices: None,
93 cuts: net.cuts().iter().map(pair).collect(),
94 links: net.links().iter().map(pair).collect(),
95 }
96}
97
98impl<'a> Deserialize<'a> for ProofStructure {
99 fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
102 Self::read(deserializer, &Limits::default())
103 }
104}
105
106impl crate::sealed::Readable for ProofStructure {}
107
108impl Readable for ProofStructure {
109 const FORM: &'static str = "proof structure";
110
111 fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
116 let net = Net::deserialize(deserializer)?;
117 if net.vertices.is_some() {
118 return Err(serde::de::Error::custom(
119 "a proof structure with boxes, whose links name its vertices: read it as one",
120 ));
121 }
122 let build = || {
123 let sequent = crate::linear::Sequent::try_from(net.sequent)?;
124 let forest = Forest::from_owned(sequent, limits)?;
125 let pair = |&(x, y): &(u32, u32)| (VertexId::new(x), VertexId::new(y));
126 let links: Vec<(VertexId, VertexId)> = net.links.iter().map(pair).collect();
127 let cuts: Vec<(VertexId, VertexId)> = net.cuts.iter().map(pair).collect();
128 let criterion = Criterion {
129 mix: net.mix,
130 order: net.order.map_or(Order::Commutative, Order::from),
131 };
132 ProofStructure::with_cuts(forest, criterion, &cuts, &links)
133 };
134 build().map_err(wire::fail)
135 }
136}
137
138#[derive(Clone, Debug, Serialize, Deserialize)]
153struct Boxed {
154 #[serde(
156 default,
157 skip_serializing_if = "Option::is_none",
158 deserialize_with = "wire::version"
159 )]
160 version: Option<u32>,
161 sequent: Sequent,
163 mix: bool,
165 vertices: Vec<(u32, Option<u32>, Option<u32>)>,
167 #[serde(default, skip_serializing_if = "Vec::is_empty")]
169 cuts: Vec<(u32, u32)>,
170 links: Vec<(u32, u32)>,
172 weakenings: Vec<(u32, u32)>,
174}
175
176impl Serialize for MellStructure {
177 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
180 boxed(self).serialize(serializer)
181 }
182}
183
184fn boxed(net: &MellStructure) -> Boxed {
186 let parts = net.parts();
187 let pair = |&(x, y): &(VertexId, VertexId)| (x.get(), y.get());
188 Boxed {
189 version: Some(wire::BOXES.max(wire::level_of_sequent(net.forest().sequent()))),
190 sequent: Sequent::from(net.forest().sequent()),
191 mix: net.criterion().mix,
192 vertices: parts
193 .vertices
194 .iter()
195 .map(|p| {
196 (
197 p.occurrence.get(),
198 p.parent.map(VertexId::get),
199 p.inside.map(VertexId::get),
200 )
201 })
202 .collect(),
203 cuts: parts.cuts.iter().map(pair).collect(),
204 links: parts.links.iter().map(pair).collect(),
205 weakenings: parts.weakenings.iter().map(pair).collect(),
206 }
207}
208
209#[derive(Serialize)]
211struct StepForm {
212 cut: (u32, u32),
214 case: crate::linear::proofs::cut::Case,
216 #[serde(skip_serializing_if = "Option::is_none")]
218 above: Option<u32>,
219}
220
221#[derive(Serialize)]
223struct EliminationForm<'a, F> {
224 version: u32,
226 net: F,
228 steps: Vec<StepForm>,
230 end: &'static str,
232 #[serde(skip_serializing_if = "Option::is_none")]
234 reason: Option<&'a crate::Error>,
235}
236
237fn record<S: Serializer, F: Serialize>(
240 serializer: S,
241 net: F,
242 version: u32,
243 steps: &[crate::linear::nets::cut::Step],
244 end: &crate::linear::proofs::cut::End,
245) -> Result<S::Ok, S::Error> {
246 use crate::linear::proofs::cut::End;
247 let reason = match end {
248 End::CutFree => None,
249 End::Refused(refusal) => Some(crate::Error::Refused(refusal.clone())),
250 };
251 EliminationForm {
252 version,
253 net,
254 steps: steps
255 .iter()
256 .map(|step| StepForm {
257 cut: (step.cut.0.get(), step.cut.1.get()),
258 case: step.case,
259 above: step.above.map(VertexId::get),
260 })
261 .collect(),
262 end: if reason.is_some() {
263 "refused"
264 } else {
265 "cut_free"
266 },
267 reason: reason.as_ref(),
268 }
269 .serialize(serializer)
270}
271
272impl Serialize for crate::linear::nets::cut::Elimination<ProofStructure> {
273 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
276 let mut net = form(&self.net);
277 let version = net.version.take().unwrap_or(wire::BASE);
278 record(serializer, net, version, &self.steps, &self.end)
279 }
280}
281
282impl Serialize for crate::linear::nets::cut::Elimination<MellStructure> {
283 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
286 let mut net = boxed(&self.net);
287 let version = net.version.take().unwrap_or(wire::BOXES);
288 record(serializer, net, version, &self.steps, &self.end)
289 }
290}
291
292impl<'a> Deserialize<'a> for MellStructure {
293 fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
296 Self::read(deserializer, &Limits::default())
297 }
298}
299
300impl crate::sealed::Readable for MellStructure {}
301
302impl Readable for MellStructure {
303 const FORM: &'static str = "proof structure with boxes";
304
305 fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
311 let boxed = Boxed::deserialize(deserializer)?;
312 let build = || {
313 let sequent = crate::linear::Sequent::try_from(boxed.sequent)?;
314 let forest = Forest::from_owned(sequent, limits)?;
315 let pair = |&(x, y): &(u32, u32)| (VertexId::new(x), VertexId::new(y));
316 let parts = Parts {
317 vertices: boxed
318 .vertices
319 .iter()
320 .map(|&(o, p, b)| match p {
321 Some(p) => {
322 Placed::new(OccId::new(o), VertexId::new(p), b.map(VertexId::new))
323 }
324 None => Placed::cut(OccId::new(o), b.map(VertexId::new)),
325 })
326 .collect(),
327 cuts: boxed.cuts.iter().map(pair).collect(),
328 links: boxed.links.iter().map(pair).collect(),
329 weakenings: boxed.weakenings.iter().map(pair).collect(),
330 };
331 let criterion = Criterion {
332 mix: boxed.mix,
333 order: Order::Commutative,
334 };
335 MellStructure::from_parts(forest, criterion, &parts, limits)
336 };
337 build().map_err(wire::fail)
338 }
339}