use super::search::Why;
use crate::Error;
use crate::limits::{Limits, Refusal, Space};
use crate::linear::proofs::InfId;
use crate::ordinary::{
Derivation, Formulas, Inference, Logic, Node, NodeId, Outcome, Rule, Sequent, Side,
Translation, Verdict, bound,
};
#[cfg(feature = "interactive")]
use crate::ordinary::{Interactive, Parts};
use crate::wire::{self, Readable};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
impl Serialize for Rule {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.name())
}
}
impl<'a> Deserialize<'a> for Rule {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
let name = <std::borrow::Cow<'a, str>>::deserialize(deserializer)?;
Rule::ALL
.into_iter()
.find(|rule| rule.name() == name)
.ok_or_else(|| serde::de::Error::custom(format!("no rule of LK or LJ is named {name}")))
}
}
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
enum FormulaForm {
#[serde(rename = "V")]
Atom(u32),
#[serde(rename = "⊤")]
True,
#[serde(rename = "⊥")]
False,
#[serde(rename = "¬")]
Not(u32),
#[serde(rename = "∧")]
And(u32, u32),
#[serde(rename = "∨")]
Or(u32, u32),
#[serde(rename = "→")]
Implies(u32, u32),
#[serde(rename = "↔")]
Iff(u32, u32),
}
impl From<Node> for FormulaForm {
fn from(node: Node) -> Self {
let i = |k: NodeId| k.index() as u32;
match node {
Node::Atom(a) => Self::Atom(a),
Node::True => Self::True,
Node::False => Self::False,
Node::Not(a) => Self::Not(i(a)),
Node::And(a, b) => Self::And(i(a), i(b)),
Node::Or(a, b) => Self::Or(i(a), i(b)),
Node::Implies(a, b) => Self::Implies(i(a), i(b)),
Node::Iff(a, b) => Self::Iff(i(a), i(b)),
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct SequentForm {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
formulas: Vec<FormulaForm>,
atoms: Vec<String>,
left: Vec<u32>,
right: Vec<u32>,
}
impl SequentForm {
fn of(formulas: &Formulas, left: &[NodeId], right: &[NodeId]) -> Self {
let ids = |list: &[NodeId]| list.iter().map(|k| k.index() as u32).collect();
Self {
version: None,
formulas: formulas
.nodes()
.iter()
.map(|&n| FormulaForm::from(n))
.collect(),
atoms: formulas.atom_names().to_vec(),
left: ids(left),
right: ids(right),
}
}
fn within(self, limits: &Limits) -> Result<(Read, Vec<NodeId>, Vec<NodeId>), Error> {
if let Some(limit) = limits.occurrences
&& self.formulas.len() as u64 > limit
{
return Err(Error::Refused(Refusal::Occurrences {
occurrences: self.formulas.len() as u64,
limit,
}));
}
let mut formulas = Formulas::default();
let mut ids: Vec<NodeId> = Vec::with_capacity(self.formulas.len());
for (n, form) in self.formulas.iter().enumerate() {
let at = |k: u32| {
ids.get(k as usize).copied().ok_or(Error::IndexOutOfBounds {
space: Space::Formula,
index: k as usize,
len: n,
})
};
let id = match *form {
FormulaForm::Atom(a) => {
let name = self.atoms.get(a as usize).ok_or(Error::IndexOutOfBounds {
space: Space::Atom,
index: a as usize,
len: self.atoms.len(),
})?;
formulas.atom(name)?
}
FormulaForm::True => formulas.add(Node::True)?,
FormulaForm::False => formulas.add(Node::False)?,
FormulaForm::Not(a) => formulas.add(Node::Not(at(a)?))?,
FormulaForm::And(a, b) => formulas.add(Node::And(at(a)?, at(b)?))?,
FormulaForm::Or(a, b) => formulas.add(Node::Or(at(a)?, at(b)?))?,
FormulaForm::Implies(a, b) => formulas.add(Node::Implies(at(a)?, at(b)?))?,
FormulaForm::Iff(a, b) => formulas.add(Node::Iff(at(a)?, at(b)?))?,
};
ids.push(id);
}
let read = Read { formulas, ids };
let left = read.ids(&self.left)?;
let right = read.ids(&self.right)?;
bound(&read.formulas, &left, &right, limits)?;
Ok((read, left, right))
}
}
struct Read {
formulas: Formulas,
ids: Vec<NodeId>,
}
impl Read {
fn ids(&self, indices: &[u32]) -> Result<Vec<NodeId>, Error> {
indices
.iter()
.map(|&k| {
self.ids
.get(k as usize)
.copied()
.ok_or(Error::IndexOutOfBounds {
space: Space::Formula,
index: k as usize,
len: self.ids.len(),
})
})
.collect()
}
}
impl Serialize for Sequent {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut form = SequentForm::of(self.formulas(), self.left(), self.right());
form.version = Some(wire::ORDINARY);
form.serialize(serializer)
}
}
impl<'a> Deserialize<'a> for Sequent {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for Sequent {}
impl Readable for Sequent {
const FORM: &'static str = "ordinary sequent";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
let form = SequentForm::deserialize(deserializer)?;
sequent(form, limits).map_err(wire::fail)
}
}
fn sequent(form: SequentForm, limits: &Limits) -> Result<Sequent, Error> {
let (read, left, right) = form.within(limits)?;
Sequent::new(read.formulas, left, right)
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct InferenceForm {
left: Vec<u32>,
right: Vec<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
rule: Option<Rule>,
#[serde(default, skip_serializing_if = "Option::is_none")]
principal: Option<(Side, usize)>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
premises: Vec<u32>,
}
impl InferenceForm {
fn of(inference: &Inference, open: bool) -> Self {
let ids = |list: &[NodeId]| list.iter().map(|k| k.index() as u32).collect();
Self {
left: ids(&inference.left),
right: ids(&inference.right),
rule: (!(open && inference.rule == Rule::Open)).then_some(inference.rule),
principal: inference.principal,
premises: inference.premises.iter().map(|p| p.get()).collect(),
}
}
fn read(self, read: &Read, len: usize) -> Result<Inference, Error> {
let premises = self
.premises
.iter()
.map(|&p| match p as usize {
p if p < len => Ok(InfId::new(p as u32)),
index => Err(Error::IndexOutOfBounds {
space: Space::Inference,
index,
len,
}),
})
.collect::<Result<_, _>>()?;
let inference = Inference {
left: read.ids(&self.left)?,
right: read.ids(&self.right)?,
rule: self.rule.unwrap_or(Rule::Open),
principal: self.principal,
premises,
};
if let Some((side, at)) = inference.principal
&& at >= inference.side(side).len()
{
return Err(Error::IndexOutOfBounds {
space: Space::Formula,
index: at,
len: inference.side(side).len(),
});
}
Ok(inference)
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
struct DerivationForm {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
logic: Logic,
sequent: SequentForm,
inferences: Vec<InferenceForm>,
}
impl From<&Derivation> for DerivationForm {
fn from(derivation: &Derivation) -> Self {
let (left, right) = derivation.sequent();
Self {
version: None,
logic: derivation.logic(),
sequent: SequentForm::of(derivation.formulas(), left, right),
inferences: derivation
.inferences()
.iter()
.map(|i| InferenceForm::of(i, false))
.collect(),
}
}
}
impl DerivationForm {
fn within(self, limits: &Limits) -> Result<Derivation, Error> {
let (read, left, right) = self.sequent.within(limits)?;
let len = self.inferences.len();
let mut parents = vec![0u8; len];
let mut inferences = Vec::with_capacity(len);
for (n, form) in self.inferences.into_iter().enumerate() {
let inference = form.read(&read, n)?;
if inference.rule == Rule::Open
&& (inference.principal.is_some() || !inference.premises.is_empty())
{
return Err(Error::Json {
form: "ordinary derivation",
message: format!("inference {n} is an open goal with a principal or premises"),
});
}
for p in &inference.premises {
parents[p.index()] = parents[p.index()].saturating_add(1);
}
inferences.push(inference);
}
let shaped = parents
.split_last()
.is_some_and(|(&root, rest)| root == 0 && rest.iter().all(|&n| n == 1));
if !shaped {
return Err(Error::Json {
form: "ordinary derivation",
message: "the inferences are no tree with its root last".to_owned(),
});
}
Ok(Derivation::from_parts(
self.logic,
read.formulas,
(left, right),
inferences,
))
}
}
impl Serialize for Derivation {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut form = DerivationForm::from(self);
form.version = Some(wire::ORDINARY);
form.serialize(serializer)
}
}
impl<'a> Deserialize<'a> for Derivation {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
impl crate::sealed::Readable for Derivation {}
impl Readable for Derivation {
const FORM: &'static str = "ordinary derivation";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
let form = DerivationForm::deserialize(deserializer)?;
form.within(limits).map_err(wire::fail)
}
}
#[derive(Serialize)]
struct OutcomeForm {
version: u32,
deduxit: &'static str,
verdict: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
reason: Option<Why>,
logic: Logic,
translation: Translation,
engine: crate::linear::search::Engine,
statistics: crate::linear::search::Statistics,
#[serde(skip_serializing_if = "Option::is_none")]
derivation: Option<DerivationForm>,
}
impl Serialize for Outcome {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let (verdict, reason, derivation) = match &self.verdict {
Verdict::Valid(d) => ("valid", None, Some(DerivationForm::from(&**d))),
Verdict::NotValid => ("not_valid", None, None),
Verdict::Unknown(r) => ("unknown", Some(Why::from(*r)), None),
};
OutcomeForm {
version: wire::ORDINARY,
deduxit: env!("CARGO_PKG_VERSION"),
verdict,
reason,
logic: self.logic,
translation: self.translation,
engine: self.linear.engine,
statistics: self.linear.statistics,
derivation,
}
.serialize(serializer)
}
}
#[cfg(feature = "interactive")]
#[derive(Clone, Debug, Serialize, Deserialize)]
struct SessionForm {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "wire::version"
)]
version: Option<u32>,
logic: Logic,
sequent: SequentForm,
inferences: Vec<InferenceForm>,
history: Vec<u32>,
}
#[cfg(feature = "interactive")]
impl Serialize for Interactive {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let (logic, formulas, inferences, history) = self.parts();
let (left, right) = self.sequent();
SessionForm {
version: Some(wire::ORDINARY),
logic,
sequent: SequentForm::of(formulas, left, right),
inferences: inferences
.iter()
.map(|i| InferenceForm::of(i, true))
.collect(),
history: history.iter().map(|h| h.get()).collect(),
}
.serialize(serializer)
}
}
#[cfg(feature = "interactive")]
impl<'a> Deserialize<'a> for Interactive {
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
Self::read(deserializer, &Limits::default())
}
}
#[cfg(feature = "interactive")]
impl crate::sealed::Readable for Interactive {}
#[cfg(feature = "interactive")]
impl Readable for Interactive {
const FORM: &'static str = "ordinary session";
fn read<'de, D: Deserializer<'de>>(deserializer: D, limits: &Limits) -> Result<Self, D::Error> {
let form = SessionForm::deserialize(deserializer)?;
session(form, limits).map_err(wire::fail)
}
}
#[cfg(feature = "interactive")]
fn session(form: SessionForm, limits: &Limits) -> Result<Interactive, Error> {
let (read, left, right) = form.sequent.within(limits)?;
let len = form.inferences.len();
let inferences = form
.inferences
.into_iter()
.map(|i| i.read(&read, len))
.collect::<Result<Vec<_>, _>>()?;
if inferences
.first()
.is_some_and(|root| root.left != left || root.right != right)
{
return Err(Error::InconsistentSession {
reason: "the root does not conclude the sequent",
});
}
let history = form
.history
.iter()
.map(|&h| match h as usize {
h if h < len => Ok(InfId::new(h as u32)),
index => Err(Error::IndexOutOfBounds {
space: Space::Inference,
index,
len,
}),
})
.collect::<Result<_, _>>()?;
Interactive::from_parts(
Parts {
logic: form.logic,
formulas: read.formulas,
inferences,
history,
},
limits,
)
}