minerva 0.2.0

//! Deterministic seal-consignment boundary examples.

use super::*;
use crate::metis::dot::RawDot;

mod ledger;
mod refusals;

/// The rank-contest falsifier, the third S213-class exhibit (ruling R-50):
/// verbatim anchors under translation cannot carry window content across
/// the seal. Re-founding re-bases a cut-live sibling's rank to the fixed
/// base, so an honest window birth that LOST its old bucket's contest
/// (its minter's clock ran behind) wins the translated bucket, flipping
/// the pair's reading. Only the judged outcome is stable, and the consignment
/// carries exactly that.
#[test]
fn a_verbatim_anchor_carry_flips_a_rank_contest_the_consignment_preserves() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(1)));
    // The cut-live sibling: honest clock rank 5, delivered everywhere.
    weave(
        &mut text,
        d(1, 2),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            rank(5),
        ),
    );

    // The window birth: same bucket, honest concurrent rank 3 (station 2
    // had not seen the sibling when it minted), so the old world reads it
    // after the sibling.
    let window_rank = Kairos::new(3, 0, 2, 0u16);
    let birth = text_delta(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            window_rank,
        ),
    );

    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(1, &boundary, &[(2, 1)]);
    let refounded = text.store().refound(&Metatheses::new()).unwrap();
    let mut shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    shadow.deliver_text(&birth).unwrap();
    let projection = shadow.projection().clone();
    assert_eq!(projection.order(), [d(1, 1), d(1, 2), d(2, 1)]);

    // The verbatim carry: anchor and rank kept under translation. The
    // sibling's rank was re-based by the re-foundation, so the window
    // birth now wins the bucket it had lost: the reading flips.
    let mut verbatim = refounded.store().clone();
    assert!(verbatim.weave(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1
            }),
            window_rank
        )
    ));
    assert_eq!(verbatim.order(), [d(1, 1), d(2, 1), d(1, 2)]);

    // The consignment bakes the judged outcome instead: exact agreement.
    let consignment = shadow.consign(&sealed).unwrap().0;
    assert_eq!(consignment.text().store().order(), projection.order());
    assert_eq!(consignment.moves().store().testimonies().count(), 0);
}

/// The first S213 falsifier through the seal: a window move lawful on the
/// old root-sibling topology is a refused cycle-former against the
/// re-founded chain, so the testimony must not cross; the consignment bakes
/// its outcome into the spelled skeleton and the movement record starts
/// empty.
#[test]
fn the_old_world_move_verdict_crosses_baked_never_as_testimony() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(2)));
    weave(&mut text, d(1, 2), locus(Anchor::Origin, rank(1)));
    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(2, &boundary, &[(2, 2)]);
    let refounded = text.store().refound(&Metatheses::new()).unwrap();

    // "(1, 1) after (1, 2)": lawful on the old topology (root siblings).
    let testimony = movement(
        d(2, 2),
        (1, 1),
        Anchor::After(RawDot {
            station: 1,
            counter: 2,
        }),
        rank(1),
    );
    let mut shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    shadow.deliver_moves(&testimony).unwrap();
    assert_eq!(shadow.recension().refused(), []);
    let projection = shadow.projection().clone();
    assert_eq!(projection.order(), [d(1, 2), d(1, 1)]);

    // Carried verbatim into the re-founded chain, the same testimony is
    // refused: the incumbent edge relation changed under it (S213).
    let translated = Metatheses::singleton(
        d(2, 2),
        Metathesis {
            target: RawDot::new(1, 1),
            to: locus(
                Anchor::After(RawDot {
                    station: 1,
                    counter: 2,
                }),
                rank(1),
            ),
        },
    );
    assert_eq!(
        refounded.store().recension(&translated).refused(),
        [d(2, 2)]
    );

    // The consignment carries the outcome, and nothing re-judges it.
    let consignment = shadow.consign(&sealed).unwrap().0;
    assert_eq!(consignment.text().store().order(), projection.order());
    assert_eq!(consignment.moves().store().testimonies().count(), 0);
    assert!(consignment.moves().context().contains(d(2, 2)));
}

/// One window of every traffic kind crosses the seal whole: the birth is
/// woven at its judged place, the moved element sits where the old world's
/// replay put it, the deleted element keeps its locus as an order
/// tombstone a native anchor can still name, and both contexts carry the
/// image of every window event dot.
#[test]
fn the_consignment_carries_births_moves_and_deletes_whole() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(3)));
    weave(&mut text, d(1, 2), locus(Anchor::Origin, rank(2)));
    weave(&mut text, d(1, 3), locus(Anchor::Origin, rank(1)));
    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(1, &boundary, &[(2, 1), (2, 2), (2, 3)]);

    let mut shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    // A window birth after (1, 1); a window delete of (1, 2); a window
    // move of (1, 3) to the document head.
    let birth = text_delta(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            Kairos::new(9, 0, 2, 0u16),
        ),
    );
    shadow.deliver_text(&birth).unwrap();
    let mut removal = DotSet::new();
    assert!(removal.insert(d(2, 2)));
    assert!(removal.insert(d(1, 2)));
    shadow.deliver_text(&Dotted::from_context(removal)).unwrap();
    let moved = movement(d(2, 3), (1, 3), Anchor::Origin, Kairos::new(11, 0, 2, 0u16));
    shadow.deliver_moves(&moved).unwrap();

    let projection = shadow.projection().clone();
    assert_eq!(projection.order(), [d(1, 3), d(1, 1), d(2, 1)]);
    let consignment = shadow.consign(&sealed).unwrap().0;
    let base = consignment.text().store();
    assert_eq!(base.order(), projection.order());

    // The window-deleted element crossed as an order tombstone at its
    // judged place: a native weave anchored to it still lands there.
    assert!(base.locus(d(1, 2)).is_some());
    assert!(!base.is_visible(d(1, 2)));
    let mut native = base.clone();
    assert!(native.weave(
        d(3, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 2
            }),
            rank(9)
        )
    ));
    assert_eq!(native.order(), [d(1, 3), d(1, 1), d(2, 1), d(3, 1)]);

    // Both pairs share one translated context carrying every event dot's
    // image the seal accounts for (text, movement, and declaration alike),
    // so each plane's floors are born gap-free on its own.
    assert_eq!(consignment.text().context(), consignment.moves().context());
    let floor = consignment.text().context().floor();
    assert_eq!(floor.get(1), 4);
    assert_eq!(floor.get(2), 3);
    assert!(consignment.moves().context().contains(d(2, 1)));
    assert!(consignment.moves().context().contains(d(2, 3)));
    assert!(consignment.text().context().contains(d(2, 2)));
}

/// The consignment is a pure function of the shadow's delta set: both arrival
/// orders derive byte-identical base pairs.
#[test]
fn the_consignment_reads_identically_in_both_arrival_orders() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(2)));
    weave(&mut text, d(1, 2), locus(Anchor::Origin, rank(1)));
    let boundary = Cut::floor_of(text.context());

    let birth = text_delta(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            Kairos::new(7, 0, 2, 0u16),
        ),
    );
    let moved = movement(d(2, 2), (1, 2), Anchor::Origin, Kairos::new(8, 0, 2, 0u16));

    let mut consignments = Vec::new();
    for reversed in [false, true] {
        let (adopted, sealed) = seal_mill(1, &boundary, &[(2, 1), (2, 2)]);
        let mut shadow = EpochStratum::new(&adopted, text.clone(), Moves::new())
            .unwrap()
            .into_transition()
            .shadow;
        if reversed {
            shadow.deliver_moves(&moved).unwrap();
            shadow.deliver_text(&birth).unwrap();
        } else {
            shadow.deliver_text(&birth).unwrap();
            shadow.deliver_moves(&moved).unwrap();
        }
        consignments.push(shadow.consign(&sealed).unwrap().0);
    }
    assert_eq!(
        consignments[0].text().store().to_bytes(),
        consignments[1].text().store().to_bytes()
    );
    assert_eq!(
        consignments[0].text().context(),
        consignments[1].text().context()
    );
    assert_eq!(
        consignments[0].moves().context(),
        consignments[1].moves().context()
    );
}

/// An identity born and superseded inside the window crosses as context
/// only: nothing in the new plane can anchor it, and its image in the
/// floors is all the next generation needs.
#[test]
fn a_window_dead_birth_crosses_as_context_only() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(1)));
    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(1, &boundary, &[(2, 1), (2, 2)]);

    let mut shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    let birth = text_delta(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            Kairos::new(5, 0, 2, 0u16),
        ),
    );
    shadow.deliver_text(&birth).unwrap();
    let mut removal = DotSet::new();
    assert!(removal.insert(d(2, 2)));
    assert!(removal.insert(d(2, 1)));
    shadow.deliver_text(&Dotted::from_context(removal)).unwrap();

    let consignment = shadow.consign(&sealed).unwrap().0;
    assert_eq!(consignment.text().store().order(), [d(1, 1)]);
    assert!(consignment.text().store().locus(d(2, 1)).is_none());
    assert!(consignment.text().context().contains(d(2, 1)));
    assert!(consignment.text().context().contains(d(2, 2)));
}

/// An identity dead at the cut is swept by the re-foundation: the consignment
/// carries neither its locus nor a context image for it (it is answerable
/// only in the shadow's lifetime and at the recognizer afterwards), and
/// the compacted floors stay perfect around the gap it leaves.
#[test]
fn a_dead_at_cut_identity_does_not_cross_the_consignment() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(2)));
    weave(
        &mut text,
        d(1, 2),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 1,
            }),
            rank(1),
        ),
    );
    weave(
        &mut text,
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 1,
                counter: 2,
            }),
            rank(1),
        ),
    );
    remove(&mut text, d(2, 1));
    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(1, &boundary, &[]);
    let shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    let consignment = shadow.consign(&sealed).unwrap().0;
    assert_eq!(consignment.text().store().order(), [d(1, 1), d(1, 2)]);
    assert_eq!(consignment.text().store().skeleton_len(), 2);
    assert!(!consignment.text().context().contains(d(2, 1)));
    assert_eq!(consignment.text().context().floor().get(2), 0);
}

/// The chain-adjacency guard at the counter ceiling: a lawful affine
/// image can be `u64::MAX`, and a lower same-station image can follow it
/// in the final order, so the guard must test adjacency without
/// overflowing (the spelling falls back to an anchored head, exactly as
/// for any non-adjacent pair).
#[test]
fn a_ceiling_image_does_not_overflow_the_chain_guard() {
    let mut text = Rhapsody::new();
    assert!(text.weave(d(2, u64::MAX), locus(Anchor::Origin, rank(5))));
    assert!(text.weave(
        d(2, 1),
        locus(
            Anchor::After(RawDot {
                station: 2,
                counter: u64::MAX
            }),
            rank(1)
        )
    ));
    let map = Rhapsody::new()
        .refound(&Metatheses::new())
        .unwrap()
        .map()
        .clone();
    let store = text
        .recension(&Metatheses::new())
        .consign_store(&map)
        .unwrap();
    assert_eq!(store.order(), [d(2, u64::MAX), d(2, 1)]);
}

/// A window move can flip a native move's verdict at the seal: the
/// consignment re-spells the topology movement acceptance depends on, so a
/// native testimony lawful against the pristine plane can be a
/// cycle-former against the consigned base (the S213 exposure, one
/// plane over). This is why the recipe defers native movement
/// testimonies until the seal: the window is short, and a verdict minted
/// against a plane the seal will replace is a verdict that can silently
/// invert.
#[test]
fn a_window_move_can_flip_a_native_move_verdict_hence_the_deferral_duty() {
    let mut text = Text::new();
    weave(&mut text, d(1, 1), locus(Anchor::Origin, rank(2)));
    weave(&mut text, d(1, 2), locus(Anchor::Origin, rank(1)));
    let boundary = Cut::floor_of(text.context());
    let (adopted, sealed) = seal_mill(1, &boundary, &[(2, 1)]);
    let refounded = text.store().refound(&Metatheses::new()).unwrap();

    // The native testimony, minted in the new dot space against the
    // pristine re-founded chain (1,1) -> (1,2): "(1,2) after (1,1)" is
    // lawful there (it restates the chain).
    let native = Metatheses::singleton(
        d(2, 5),
        Metathesis {
            target: RawDot::new(1, 2),
            to: locus(
                Anchor::After(RawDot {
                    station: 1,
                    counter: 1,
                }),
                Kairos::new(9, 0, 2, 0u16),
            ),
        },
    );
    assert_eq!(refounded.store().recension(&native).refused(), []);

    // The old-window move reverses the pair; the consignment re-spells the
    // chain as (1,2) -> (1,1), and the same native testimony is now a
    // cycle-former.
    let mut shadow = EpochStratum::new(&adopted, text, Moves::new())
        .unwrap()
        .into_transition()
        .shadow;
    shadow
        .deliver_moves(&movement(
            d(2, 1),
            (1, 1),
            Anchor::After(RawDot {
                station: 1,
                counter: 2,
            }),
            rank(1),
        ))
        .unwrap();
    let consignment = shadow.consign(&sealed).unwrap().0;
    assert_eq!(consignment.text().store().order(), [d(1, 2), d(1, 1)]);
    assert_eq!(
        consignment.text().store().recension(&native).refused(),
        [d(2, 5)]
    );
}