Enum Divergence 

pub enum Divergence {
    EmptyCorpus,
    Faulted {
        side: Side,
        input: usize,
        fault: ChoreoFault,
    },
    MissingTensor {
        side: Side,
        input: usize,
        tensor: TensorId,
    },
    Representation {
        input: usize,
        tensor: TensorId,
        a: &'static str,
        b: &'static str,
        a_len: usize,
        b_len: usize,
    },
    Element {
        input: usize,
        tensor: TensorId,
        elem: usize,
        a: Elem,
        b: Elem,
        differing: usize,
        total: usize,
    },
}

Why two programs are not the same program.

★ NEVER A BARE bool. “Not equivalent” is unactionable; a failed differential has to say which input of the corpus broke it, which tensor, which element, and what the two sides put there — otherwise the next person re-derives all of that by hand before they can start.

Variants

EmptyCorpus

The caller passed no inputs. ★ Fail-closed: a validator handed nothing to check must never answer “equivalent”, because a vacuous pass reads exactly like a proof.

Faulted

One side could not be evaluated at all — a choreography fault, not an arithmetic disagreement.

Fields

side: Side

input: usize

fault: ChoreoFault

MissingTensor

One side produced an output tensor the other never produced.

Fields

side: Side

input: usize

tensor: TensorId

Representation

The same tensor came back in two different representations (int vs float, or two lengths).

Fields

input: usize

tensor: TensorId

a: &'static str

b: &'static str

a_len: usize

b_len: usize

Element

The two sides computed different numbers. elem is the FIRST differing flat index (row-major over the tensor’s element shape); differing of total says how much of the tensor moved, which is what separates “one rounding” from “the whole rewrite is wrong”.

Fields

input: usize

tensor: TensorId

elem: usize

a: Elem

b: Elem

differing: usize

total: usize

Trait Implementations

impl Clone for Divergence

fn clone(&self) -> Divergence

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Divergence

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Divergence

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Divergence

fn eq(&self, other: &Divergence) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Divergence