auslander 0.9.0

Computational representation theory of finite-dimensional bound quiver algebras
Documentation
use super::parser::{
    Value, as_string, as_u32, as_u64, as_usize, decode_list, decode_relation, decode_relations,
    decode_word, decode_words, obj_fields, shape, tuple,
};
use super::{
    AmbiguityEntry, AmbiguityKind, AutomatonData, CertParseError, Certificate, FinitenessData,
    OriginTerm, QuiverData, Trace, TraceStep,
};

fn decode_quiver(value: &Value) -> Result<QuiverData, CertParseError> {
    let mut values = obj_fields(value, "quiver", &["vertices", "arrows"])?.into_iter();
    Ok(QuiverData {
        vertices: as_u32(
            values.next().expect("one value per object key"),
            "quiver.vertices",
        )?,
        arrows: decode_list(
            values.next().expect("one value per object key"),
            "quiver.arrows",
            |pair| {
                let [source, target] =
                    tuple(pair, "quiver.arrows", "expected a [source, target] pair")?;
                Ok((
                    as_u32(source, "quiver.arrows")?,
                    as_u32(target, "quiver.arrows")?,
                ))
            },
        )?,
    })
}

fn decode_origin_term(value: &Value) -> Result<OriginTerm, CertParseError> {
    let mut values = obj_fields(
        value,
        "origin term",
        &["coeff", "left", "input_index", "right"],
    )?
    .into_iter();
    Ok(OriginTerm {
        coeff: as_u64(
            values.next().expect("one value per object key"),
            "origin term coeff",
        )?,
        left: decode_word(
            values.next().expect("one value per object key"),
            "origin term left",
        )?,
        input_index: as_usize(
            values.next().expect("one value per object key"),
            "origin term input_index",
        )?,
        right: decode_word(
            values.next().expect("one value per object key"),
            "origin term right",
        )?,
    })
}

fn decode_step(value: &Value) -> Result<TraceStep, CertParseError> {
    let mut values = obj_fields(
        value,
        "trace step",
        &["word", "basis_index", "left", "right", "coeff"],
    )?
    .into_iter();
    Ok(TraceStep {
        word: decode_word(
            values.next().expect("one value per object key"),
            "trace step word",
        )?,
        basis_index: as_usize(
            values.next().expect("one value per object key"),
            "trace step basis_index",
        )?,
        left: decode_word(
            values.next().expect("one value per object key"),
            "trace step left",
        )?,
        right: decode_word(
            values.next().expect("one value per object key"),
            "trace step right",
        )?,
        coeff: as_u64(
            values.next().expect("one value per object key"),
            "trace step coeff",
        )?,
    })
}

fn decode_trace(value: &Value) -> Result<Trace, CertParseError> {
    let mut values = obj_fields(value, "trace", &["start", "steps"])?.into_iter();
    Ok(Trace {
        start: decode_relation(
            values.next().expect("one value per object key"),
            "trace start",
        )?,
        steps: decode_list(
            values.next().expect("one value per object key"),
            "trace steps",
            decode_step,
        )?,
    })
}

fn decode_kind(value: &Value) -> Result<AmbiguityKind, CertParseError> {
    match as_string(value, "ambiguity kind")?.as_str() {
        "overlap" => Ok(AmbiguityKind::Overlap),
        "inclusion" => Ok(AmbiguityKind::Inclusion),
        other => Err(shape(
            "ambiguity kind",
            format!("expected \"overlap\" or \"inclusion\", got {other:?}"),
        )),
    }
}

fn decode_ambiguity(value: &Value) -> Result<AmbiguityEntry, CertParseError> {
    let mut values =
        obj_fields(value, "ambiguity", &["i", "j", "kind", "offset", "trace"])?.into_iter();
    Ok(AmbiguityEntry {
        i: as_usize(
            values.next().expect("one value per object key"),
            "ambiguity i",
        )?,
        j: as_usize(
            values.next().expect("one value per object key"),
            "ambiguity j",
        )?,
        kind: decode_kind(values.next().expect("one value per object key"))?,
        offset: as_usize(
            values.next().expect("one value per object key"),
            "ambiguity offset",
        )?,
        trace: decode_trace(values.next().expect("one value per object key"))?,
    })
}

fn decode_automaton(value: &Value) -> Result<AutomatonData, CertParseError> {
    let mut values = obj_fields(value, "automaton", &["states", "transitions"])?.into_iter();
    Ok(AutomatonData {
        states: decode_words(
            values.next().expect("one value per object key"),
            "automaton.states",
        )?,
        transitions: decode_list(
            values.next().expect("one value per object key"),
            "automaton.transitions",
            |triple| {
                let [state, arrow, next] = tuple(
                    triple,
                    "automaton.transitions",
                    "expected a [state, arrow, next state] triple",
                )?;
                Ok((
                    as_usize(state, "automaton.transitions")?,
                    as_u32(arrow, "automaton.transitions")?,
                    as_usize(next, "automaton.transitions")?,
                ))
            },
        )?,
    })
}

struct BasicFields {
    schema: String,
    field: u64,
    quiver: QuiverData,
    order: String,
}

struct CollectionFields {
    input_relations: Vec<super::RelationData>,
    basis: Vec<super::RelationData>,
    origin: Vec<Vec<OriginTerm>>,
    membership: Vec<Trace>,
    ambiguities: Vec<AmbiguityEntry>,
    normal_words: Vec<Vec<u32>>,
    automaton: AutomatonData,
    finiteness: FinitenessData,
}

fn certificate_fields(value: &Value) -> Result<Vec<&Value>, CertParseError> {
    obj_fields(
        value,
        "certificate",
        &[
            "schema",
            "field",
            "quiver",
            "order",
            "input_relations",
            "basis",
            "origin",
            "membership",
            "ambiguities",
            "normal_words",
            "automaton",
            "finiteness",
        ],
    )
}

fn decode_basic_fields(values: &[&Value]) -> Result<BasicFields, CertParseError> {
    Ok(BasicFields {
        schema: as_string(values[0], "schema")?,
        field: as_u64(values[1], "field")?,
        quiver: decode_quiver(values[2])?,
        order: as_string(values[3], "order")?,
    })
}

fn decode_collection_fields(values: &[&Value]) -> Result<CollectionFields, CertParseError> {
    Ok(CollectionFields {
        input_relations: decode_relations(values[4], "input_relations")?,
        basis: decode_relations(values[5], "basis")?,
        origin: decode_list(values[6], "origin", |terms| {
            decode_list(terms, "origin", decode_origin_term)
        })?,
        membership: decode_list(values[7], "membership", decode_trace)?,
        ambiguities: decode_list(values[8], "ambiguities", decode_ambiguity)?,
        normal_words: decode_words(values[9], "normal_words")?,
        automaton: decode_automaton(values[10])?,
        finiteness: decode_finiteness(values[11])?,
    })
}

pub(super) fn certificate(value: &Value) -> Result<Certificate, CertParseError> {
    let values = certificate_fields(value)?;
    let basic = decode_basic_fields(&values)?;
    let collections = decode_collection_fields(&values)?;
    Ok(Certificate {
        schema: basic.schema,
        field: basic.field,
        quiver: basic.quiver,
        order: basic.order,
        input_relations: collections.input_relations,
        basis: collections.basis,
        origin: collections.origin,
        membership: collections.membership,
        ambiguities: collections.ambiguities,
        normal_words: collections.normal_words,
        automaton: collections.automaton,
        finiteness: collections.finiteness,
    })
}

fn decode_finiteness(value: &Value) -> Result<FinitenessData, CertParseError> {
    let (key, payload) = finiteness_pair(value)?;
    match key {
        "finite" => decode_finite_flag(payload),
        "infinite" => decode_infinite_witness(payload),
        _ => Err(shape(
            "finiteness",
            "expected exactly one key, \"finite\" or \"infinite\"".to_string(),
        )),
    }
}

fn finiteness_pair(value: &Value) -> Result<(&str, &Value), CertParseError> {
    let Value::Obj(pairs) = value else {
        return Err(shape("finiteness", "expected an object".to_string()));
    };
    match pairs.as_slice() {
        [(key, payload)] => Ok((key, payload)),
        _ => Err(shape(
            "finiteness",
            "expected exactly one key, \"finite\" or \"infinite\"".to_string(),
        )),
    }
}

fn decode_finite_flag(value: &Value) -> Result<FinitenessData, CertParseError> {
    match value {
        Value::Bool(true) => Ok(FinitenessData::Finite),
        _ => Err(shape(
            "finiteness",
            "the value of \"finite\" must be the literal true".to_string(),
        )),
    }
}

fn decode_infinite_witness(value: &Value) -> Result<FinitenessData, CertParseError> {
    let fields = obj_fields(value, "finiteness.infinite", &["prefix", "cycle"])?;
    Ok(FinitenessData::Infinite {
        prefix: decode_word(fields[0], "finiteness.infinite.prefix")?,
        cycle: decode_word(fields[1], "finiteness.infinite.cycle")?,
    })
}