Struct BinaryRelation 

pub struct BinaryRelation<A: Ord, B: Ord> { /* private fields */ }

Finite binary relation type. A finite binary relation.

The starter implementation stores pairs in a BTreeSet so iteration order is deterministic.

Composition direction is:

r.compose(&s) = { (a, c) | exists b. (a, b) in r and (b, c) in s }

Examples

use relmath::{BinaryRelation, UnaryRelation};

let user_role = BinaryRelation::from_pairs([
    ("ann", "admin"),
    ("bob", "reviewer"),
]);

let extra_role = BinaryRelation::from_pairs([
    ("bob", "reviewer"),
    ("cara", "guest"),
]);

let role_permission = BinaryRelation::from_pairs([
    ("admin", "read"),
    ("reviewer", "approve"),
    ("guest", "view"),
]);

assert_eq!(
    user_role.union(&extra_role).to_vec(),
    vec![("ann", "admin"), ("bob", "reviewer"), ("cara", "guest")]
);
assert_eq!(
    user_role.intersection(&extra_role).to_vec(),
    vec![("bob", "reviewer")]
);
assert_eq!(user_role.difference(&extra_role).to_vec(), vec![("ann", "admin")]);
assert_eq!(
    user_role.converse().to_vec(),
    vec![("admin", "ann"), ("reviewer", "bob")]
);

let effective_permission = user_role.union(&extra_role).compose(&role_permission);
assert!(effective_permission.contains(&"ann", &"read"));
assert_eq!(
    effective_permission.iter().copied().collect::<Vec<_>>(),
    vec![("ann", "read"), ("bob", "approve"), ("cara", "view")]
);
assert_eq!(
    effective_permission.domain().to_vec(),
    vec!["ann", "bob", "cara"]
);
assert_eq!(
    effective_permission.range().to_vec(),
    vec!["approve", "read", "view"]
);
assert_eq!(
    effective_permission
        .restrict_domain(&UnaryRelation::from_values(["ann", "cara"]))
        .to_vec(),
    vec![("ann", "read"), ("cara", "view")]
);
assert_eq!(
    effective_permission
        .restrict_range(&UnaryRelation::from_values(["read", "view"]))
        .to_vec(),
    vec![("ann", "read"), ("cara", "view")]
);
assert_eq!(
    effective_permission.image(&UnaryRelation::singleton("bob")).to_vec(),
    vec!["approve"]
);
assert_eq!(
    effective_permission
        .preimage(&UnaryRelation::from_values(["read", "view"]))
        .to_vec(),
    vec!["ann", "cara"]
);

Implementations

impl<A: Ord, B: Ord> BinaryRelation<A, B>

pub fn new() -> Self

Creates an empty binary relation.

pub fn from_pairs<I>(pairs: I) -> Self

where I: IntoIterator<Item = (A, B)>,

Creates a binary relation from the provided pairs.

Examples found in repository

examples/workflow.rs (lines 6-10)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (lines 6-12)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (lines 6-11)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/relation_view.rs (line 11)

fn main() -> Result<(), relmath::NaryRelationError> {
    let people = UnaryRelation::from_values(["Ada", "Bob"]);
    let parent = BinaryRelation::from_pairs([("Ada", "Bob"), ("Bob", "Cara")]);
    let enrollments =
        NaryRelation::from_rows(["student", "course"], [["Ada", "Math"], ["Bob", "Physics"]])?;

    assert_eq!(tuple_count(&people), 2);
    assert_eq!(tuple_count(&parent), 2);
    assert_eq!(tuple_count(&enrollments), 2);

    assert_eq!(
        people.tuples().copied().collect::<Vec<_>>(),
        vec!["Ada", "Bob"]
    );
    assert_eq!(
        parent.tuples().copied().collect::<Vec<_>>(),
        vec![("Ada", "Bob"), ("Bob", "Cara")]
    );
    assert_eq!(
        enrollments
            .tuples()
            .map(|row| row.to_vec())
            .collect::<Vec<_>>(),
        vec![vec!["Ada", "Math"], vec!["Bob", "Physics"]]
    );

    println!("people: {:?}", people.tuples().copied().collect::<Vec<_>>());
    println!("parent: {:?}", parent.tuples().copied().collect::<Vec<_>>());
    println!(
        "enrollments: {:?}",
        enrollments
            .tuples()
            .map(|row| row.to_vec())
            .collect::<Vec<_>>()
    );

    Ok(())
}

examples/provenance.rs (lines 12-15)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

examples/carrier.rs (line 6)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn insert(&mut self, left: A, right: B) -> bool

Inserts a pair into the relation.

Returns true when the pair was not already present.

pub fn contains(&self, left: &A, right: &B) -> bool

Returns true when the relation contains the given pair.

Examples found in repository

examples/workflow.rs (line 17)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 21)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 26)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/carrier.rs (line 35)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn iter(&self) -> impl Iterator<Item = &(A, B)>

Returns an iterator over the stored pairs in deterministic order.

pub fn domain(&self) -> UnaryRelation<A>

where A: Clone,

Returns the domain of the relation.

pub fn range(&self) -> UnaryRelation<B>

where B: Clone,

Returns the range of the relation.

pub fn converse(&self) -> BinaryRelation<B, A>

where A: Clone, B: Clone,

Returns the converse relation.

pub fn union(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the union of self and other.

pub fn intersection(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the intersection of self and other.

pub fn difference(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the set difference self \ other.

pub fn restrict_domain(&self, allowed: &UnaryRelation<A>) -> Self

where A: Clone, B: Clone,

Restricts the domain of the relation to allowed.

pub fn restrict_range(&self, allowed: &UnaryRelation<B>) -> Self

where A: Clone, B: Clone,

Restricts the range of the relation to allowed.

pub fn image(&self, sources: &UnaryRelation<A>) -> UnaryRelation<B>

where B: Clone,

Computes the image of sources through the relation.

Returns { b | exists a in sources. (a, b) in self }.

Examples found in repository

examples/workflow.rs (line 22)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 19)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 24)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/annotated.rs (line 44)

fn main() {
    let confirmations = AnnotatedRelation::from_facts([
        (("Alice", "Math"), SupportCount(1)),
        (("Alice", "Math"), SupportCount(1)),
        (("Bob", "Physics"), SupportCount(1)),
        (("Cara", "Logic"), SupportCount::zero()),
    ]);

    let exact_completed = confirmations.to_binary_relation();
    let alice = UnaryRelation::singleton("Alice");

    assert_eq!(
        confirmations.annotation_of(&("Alice", "Math")),
        Some(&SupportCount(2))
    );
    assert_eq!(exact_completed.image(&alice).to_vec(), vec!["Math"]);
    assert!(!confirmations.contains_fact(&("Cara", "Logic")));
    assert_eq!(
        confirmations
            .iter()
            .map(|(fact, count)| (*fact, count.0))
            .collect::<Vec<_>>(),
        vec![(("Alice", "Math"), 2), (("Bob", "Physics"), 1)]
    );

    println!(
        "stored support counts: {:?}",
        confirmations
            .iter()
            .map(|(fact, count)| (*fact, count.0))
            .collect::<Vec<_>>()
    );
}

examples/provenance.rs (line 25)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

examples/valid_time.rs (line 59)

fn main() {
    let assignments = ValidTimeRelation::from_facts([
        (
            ("alice", "review"),
            Interval::new(1, 3).expect("expected valid interval"),
        ),
        (
            ("alice", "review"),
            Interval::new(3, 5).expect("expected valid interval"),
        ),
        (
            ("bob", "approve"),
            Interval::new(2, 4).expect("expected valid interval"),
        ),
    ]);

    let alice = UnaryRelation::singleton("alice");
    let fact_support = assignments.support();
    let exact_support = assignments.to_binary_relation();
    let audit_window = Interval::new(2, 4).expect("expected valid interval");
    let active_at_three = assignments.snapshot_at(&3);
    let audit_assignments = assignments.restrict_to(&audit_window);

    assert_eq!(
        assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(1, 5).expect("expected valid interval")]
    );
    assert!(assignments.is_active_at(&("alice", "review"), &4));
    assert!(!assignments.is_active_at(&("alice", "review"), &5));
    assert_eq!(
        active_at_three.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        fact_support.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(2, 4).expect("expected valid interval")]
    );
    assert_eq!(
        audit_assignments.to_binary_relation().to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(exact_support.image(&alice).to_vec(), vec!["review"]);

    println!(
        "fact support: {:?}; active at t=3: {:?}; audit restriction: {:?}",
        fact_support.to_vec(),
        active_at_three.to_vec(),
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec()
    );
}

pub fn preimage(&self, targets: &UnaryRelation<B>) -> UnaryRelation<A>

where A: Clone,

Computes the preimage of targets through the relation.

Returns { a | exists b in targets. (a, b) in self }.

pub fn compose<C>(&self, rhs: &BinaryRelation<B, C>) -> BinaryRelation<A, C>

where A: Clone, B: Clone, C: Clone + Ord,

Composes self with rhs.

The result contains (a, c) whenever there exists b such that (a, b) is in self and (b, c) is in rhs.

Examples

use relmath::BinaryRelation;

let user_role = BinaryRelation::from_pairs([
    ("ann", "admin"),
    ("bob", "reviewer"),
]);
let role_permission = BinaryRelation::from_pairs([
    ("admin", "read"),
    ("reviewer", "approve"),
]);

let effective_permission = user_role.compose(&role_permission);

assert_eq!(
    effective_permission.to_vec(),
    vec![("ann", "read"), ("bob", "approve")]
);

Examples found in repository

examples/family.rs (line 15)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 22)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/provenance.rs (line 18)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

pub fn to_vec(&self) -> Vec<(A, B)>

where A: Clone, B: Clone,

Converts the relation into a sorted vector of pairs.

Examples found in repository

examples/capability_boundaries.rs (line 17)

fn exact_pairs<R>(relation: &R) -> BinaryRelation<&'static str, &'static str>
where
    R: ExactSupport<(&'static str, &'static str)>
        + ToExactBinaryRelation<&'static str, &'static str>,
{
    assert_eq!(
        relation.exact_support().to_vec(),
        relation.to_binary_relation().to_vec()
    );
    relation.to_binary_relation()
}

fn main() {
    let evidence = ProvenanceRelation::from_facts([
        (("alice", "review"), "directory"),
        (("bob", "approve"), "policy"),
    ]);
    let permissions = AnnotatedRelation::from_facts([
        (("alice", "review"), BooleanSemiring::TRUE),
        (("bob", "approve"), BooleanSemiring::TRUE),
    ]);
    let schedule = ValidTimeRelation::from_facts([
        (
            ("alice", "review"),
            Interval::new(1, 3).expect("expected valid interval"),
        ),
        (
            ("bob", "approve"),
            Interval::new(2, 4).expect("expected valid interval"),
        ),
    ]);

    let exact_evidence = exact_pairs(&evidence);
    let exact_permissions = exact_pairs(&permissions);
    let exact_schedule = exact_pairs(&schedule);

    assert_eq!(
        exact_evidence.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(exact_permissions.to_vec(), exact_evidence.to_vec());
    assert_eq!(exact_schedule.to_vec(), exact_evidence.to_vec());

    assert_eq!(
        evidence
            .why(&("alice", "review"))
            .expect("expected witness")
            .to_vec(),
        vec!["directory"]
    );
    assert_eq!(
        permissions.annotation_of(&("alice", "review")),
        Some(&BooleanSemiring::TRUE)
    );
    assert_eq!(
        schedule
            .valid_time_of(&("alice", "review"))
            .expect("expected interval support")
            .to_vec(),
        vec![Interval::new(1, 3).expect("expected valid interval")]
    );

    println!(
        "witness={:?}, annotation={:?}, interval_support={:?}, exact_support={:?}",
        evidence
            .why(&("alice", "review"))
            .expect("expected witness")
            .to_vec(),
        permissions.annotation_of(&("alice", "review")),
        schedule
            .valid_time_of(&("alice", "review"))
            .expect("expected interval support")
            .to_vec(),
        exact_schedule.to_vec()
    );
}

examples/family.rs (line 25)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/carrier.rs (line 16)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

examples/valid_time.rs (line 56)

fn main() {
    let assignments = ValidTimeRelation::from_facts([
        (
            ("alice", "review"),
            Interval::new(1, 3).expect("expected valid interval"),
        ),
        (
            ("alice", "review"),
            Interval::new(3, 5).expect("expected valid interval"),
        ),
        (
            ("bob", "approve"),
            Interval::new(2, 4).expect("expected valid interval"),
        ),
    ]);

    let alice = UnaryRelation::singleton("alice");
    let fact_support = assignments.support();
    let exact_support = assignments.to_binary_relation();
    let audit_window = Interval::new(2, 4).expect("expected valid interval");
    let active_at_three = assignments.snapshot_at(&3);
    let audit_assignments = assignments.restrict_to(&audit_window);

    assert_eq!(
        assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(1, 5).expect("expected valid interval")]
    );
    assert!(assignments.is_active_at(&("alice", "review"), &4));
    assert!(!assignments.is_active_at(&("alice", "review"), &5));
    assert_eq!(
        active_at_three.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        fact_support.to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec(),
        vec![Interval::new(2, 4).expect("expected valid interval")]
    );
    assert_eq!(
        audit_assignments.to_binary_relation().to_vec(),
        vec![("alice", "review"), ("bob", "approve")]
    );
    assert_eq!(exact_support.image(&alice).to_vec(), vec!["review"]);

    println!(
        "fact support: {:?}; active at t=3: {:?}; audit restriction: {:?}",
        fact_support.to_vec(),
        active_at_three.to_vec(),
        audit_assignments
            .valid_time_of(&("alice", "review"))
            .expect("expected support")
            .to_vec()
    );
}

impl<T: Ord> BinaryRelation<T, T>

pub fn carrier(&self) -> UnaryRelation<T>

where T: Clone,

Returns the carrier induced by the relation: domain union range.

This is support-derived carrier information, not an explicit crate::FiniteCarrier. Use crate::FiniteCarrier when the declared domain must remain visible even for disconnected values that do not appear in stored pairs.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let explicit = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

assert_eq!(step.carrier().to_vec(), vec!["Draft", "Review"]);
assert_eq!(explicit.to_vec(), vec!["Archived", "Draft", "Review"]);

Examples found in repository

examples/carrier.rs (line 9)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn identity(carrier: &UnaryRelation<T>) -> Self

where T: Clone,

Returns the identity relation on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let carrier = UnaryRelation::from_values(["Draft", "Review"]);

assert_eq!(
    BinaryRelation::identity(&carrier).to_vec(),
    vec![("Draft", "Draft"), ("Review", "Review")]
);

// Use `identity_on` when the carrier should remain explicit.
let explicit = relmath::FiniteCarrier::from_values(["Draft", "Review"]);
assert_eq!(BinaryRelation::identity_on(&explicit).to_vec(), BinaryRelation::identity(&carrier).to_vec());

Examples found in repository

examples/carrier.rs (line 10)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn identity_on(carrier: &FiniteCarrier<T>) -> Self

where T: Clone,

Returns the identity relation on an explicit finite carrier.

This is the G7 carrier-aware companion to Self::identity. It keeps the carrier explicit at the API boundary instead of first converting it into a unary relation.

Examples

use relmath::{BinaryRelation, FiniteCarrier, UnaryRelation};

let carrier = FiniteCarrier::from_values(["Draft", "Review"]);
let unary = UnaryRelation::from_values(["Draft", "Review"]);

assert_eq!(
    BinaryRelation::identity_on(&carrier).to_vec(),
    vec![("Draft", "Draft"), ("Review", "Review")]
);
assert_eq!(
    BinaryRelation::identity_on(&carrier).to_vec(),
    BinaryRelation::identity(&unary).to_vec()
);

Examples found in repository

examples/carrier.rs (line 11)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn transitive_closure(&self) -> Self

where T: Clone,

Computes the transitive closure of the relation.

Examples

use relmath::BinaryRelation;

let step = BinaryRelation::from_pairs([
    ("Draft", "Review"),
    ("Review", "Approved"),
]);

assert_eq!(
    step.transitive_closure().to_vec(),
    vec![
        ("Draft", "Approved"),
        ("Draft", "Review"),
        ("Review", "Approved"),
    ]
);

pub fn reflexive_transitive_closure(&self, carrier: &UnaryRelation<T>) -> Self

where T: Clone,

Computes the reflexive-transitive closure on the given carrier.

Values that appear in carrier but not in any pair still gain their identity edge in the result.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let states = UnaryRelation::from_values(["Draft", "Review", "Archived"]);
let reachable = step.reflexive_transitive_closure(&states);

assert!(reachable.contains(&"Archived", &"Archived"));
assert!(reachable.contains(&"Draft", &"Review"));

let explicit_states = relmath::FiniteCarrier::from_values(["Draft", "Review", "Archived"]);
assert_eq!(
    step.reflexive_transitive_closure_on(&explicit_states).to_vec(),
    reachable.to_vec()
);

Examples found in repository

examples/workflow.rs (line 14)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 16)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/carrier.rs (line 30)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn reflexive_transitive_closure_on( &self, carrier: &FiniteCarrier<T>, ) -> Self

where T: Clone,

Computes the reflexive-transitive closure on an explicit finite carrier.

Values that appear in carrier but not in any pair still gain their identity edge in the result.

This is the G7 carrier-aware companion to Self::reflexive_transitive_closure.

Examples

use relmath::{BinaryRelation, FiniteCarrier, UnaryRelation};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let explicit_states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);
let unary_states = UnaryRelation::from_values(["Draft", "Review", "Archived"]);
let reachable = step.reflexive_transitive_closure_on(&explicit_states);

assert!(reachable.contains(&"Archived", &"Archived"));
assert!(reachable.contains(&"Draft", &"Review"));
assert_eq!(reachable.to_vec(), step.reflexive_transitive_closure(&unary_states).to_vec());

Examples found in repository

examples/carrier.rs (line 12)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn is_reflexive(&self, carrier: &UnaryRelation<T>) -> bool

Returns true when the relation is reflexive on carrier.

Use Self::is_reflexive_on when the carrier should remain explicit as a crate::FiniteCarrier.

pub fn is_reflexive_on(&self, carrier: &FiniteCarrier<T>) -> bool

Returns true when the relation is reflexive on an explicit finite carrier.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let aliases = BinaryRelation::from_pairs([
    ("A. Smith", "A. Smith"),
    ("A. Smith", "Alice Smith"),
    ("Alice Smith", "A. Smith"),
    ("Alice Smith", "Alice Smith"),
]);
let carrier = FiniteCarrier::from_values(["A. Smith", "Alice Smith"]);

assert!(aliases.is_reflexive_on(&carrier));

Examples found in repository

examples/carrier.rs (line 33)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn is_irreflexive(&self, carrier: &UnaryRelation<T>) -> bool

Returns true when the relation is irreflexive on carrier.

Use Self::is_irreflexive_on when the carrier should remain explicit as a crate::FiniteCarrier.

pub fn is_irreflexive_on(&self, carrier: &FiniteCarrier<T>) -> bool

Returns true when the relation is irreflexive on an explicit finite carrier.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let carrier = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

assert!(step.is_irreflexive_on(&carrier));

Examples found in repository

examples/carrier.rs (line 34)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn is_symmetric(&self) -> bool

Returns true when the relation is symmetric.

pub fn is_antisymmetric(&self) -> bool

Returns true when the relation is antisymmetric.

pub fn is_transitive(&self) -> bool

where T: Clone,

Returns true when the relation is transitive.

pub fn is_equivalence(&self, carrier: &UnaryRelation<T>) -> bool

where T: Clone,

Returns true when the relation is an equivalence relation on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let aliases = BinaryRelation::from_pairs([
    ("A. Smith", "A. Smith"),
    ("A. Smith", "Alice Smith"),
    ("Alice Smith", "A. Smith"),
    ("Alice Smith", "Alice Smith"),
]);
let carrier = UnaryRelation::from_values(["A. Smith", "Alice Smith"]);

assert!(aliases.is_equivalence(&carrier));

let explicit = relmath::FiniteCarrier::from_values(["A. Smith", "Alice Smith"]);
assert!(aliases.is_equivalence_on(&explicit));

pub fn is_equivalence_on(&self, carrier: &FiniteCarrier<T>) -> bool

where T: Clone,

Returns true when the relation is an equivalence relation on an explicit finite carrier.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let aliases = BinaryRelation::from_pairs([
    ("A. Smith", "A. Smith"),
    ("A. Smith", "Alice Smith"),
    ("Alice Smith", "A. Smith"),
    ("Alice Smith", "Alice Smith"),
]);
let carrier = FiniteCarrier::from_values(["A. Smith", "Alice Smith"]);

assert!(aliases.is_equivalence_on(&carrier));

pub fn is_partial_order(&self, carrier: &UnaryRelation<T>) -> bool

where T: Clone,

Returns true when the relation is a partial order on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let divides = BinaryRelation::from_pairs([
    (1_u8, 1_u8),
    (1, 2),
    (1, 4),
    (2, 2),
    (2, 4),
    (4, 4),
]);
let carrier = UnaryRelation::from_values([1_u8, 2_u8, 4_u8]);

assert!(divides.is_partial_order(&carrier));

let explicit = relmath::FiniteCarrier::from_values([1_u8, 2_u8, 4_u8]);
assert!(divides.is_partial_order_on(&explicit));

pub fn is_partial_order_on(&self, carrier: &FiniteCarrier<T>) -> bool

where T: Clone,

Returns true when the relation is a partial order on an explicit finite carrier.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let divides = BinaryRelation::from_pairs([
    (1_u8, 1_u8),
    (1, 2),
    (1, 4),
    (2, 2),
    (2, 4),
    (4, 4),
]);
let carrier = FiniteCarrier::from_values([1_u8, 2_u8, 4_u8]);

assert!(divides.is_partial_order_on(&carrier));

Trait Implementations

impl<A: Clone + Ord, B: Clone + Ord> Clone for BinaryRelation<A, B>

fn clone(&self) -> BinaryRelation<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Ord, B: Debug + Ord> Debug for BinaryRelation<A, B>

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

Formats the value using the given formatter.

impl<A: Ord, B: Ord> Default for BinaryRelation<A, B>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Ord, B: Ord> Extend<(A, B)> for BinaryRelation<A, B>

fn extend<I: IntoIterator<Item = (A, B)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A: Ord, B: Ord> FiniteRelation for BinaryRelation<A, B>

fn len(&self) -> usize

Returns the number of stored tuples in the relation.

fn is_empty(&self) -> bool

Returns true when the relation contains no tuples.

impl<A: Ord, B: Ord> FromIterator<(A, B)> for BinaryRelation<A, B>

fn from_iter<I: IntoIterator<Item = (A, B)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, A: Ord, B: Ord> IntoIterator for &'a BinaryRelation<A, B>

type Item = &'a (A, B)

The type of the elements being iterated over.

type IntoIter = Iter<'a, (A, B)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Ord, B: Ord> IntoIterator for BinaryRelation<A, B>

type Item = (A, B)

The type of the elements being iterated over.

type IntoIter = IntoIter<(A, B)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: PartialEq + Ord, B: PartialEq + Ord> PartialEq for BinaryRelation<A, B>

fn eq(&self, other: &BinaryRelation<A, B>) -> 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<A: Ord, B: Ord> RelationView for BinaryRelation<A, B>

type Tuple<'a> = &'a (A, B) where Self: 'a

Borrowed tuple item yielded by Self::tuples.

fn tuples(&self) -> impl Iterator<Item = Self::Tuple<'_>>

Returns the stored tuples in deterministic order.

impl<A: Eq + Ord, B: Eq + Ord> Eq for BinaryRelation<A, B>

impl<A: Ord, B: Ord> StructuralPartialEq for BinaryRelation<A, B>