Struct ProvenanceSet 

pub struct ProvenanceSet<P: Ord> { /* private fields */ }

Deterministic provenance tokens attached to one stored fact.

ProvenanceSet<P> is the user-visible witness for a fact in this first G3 slice. It is an exact BTreeSet-backed set of tokens or labels, not a derivation DAG.

Examples

use relmath::provenance::{ProvenanceRelation, ProvenanceSet};

let empty = ProvenanceSet::<&str>::default();
assert!(empty.is_empty());

let evidence = ProvenanceRelation::from_facts([
    (("BRCA1", "BreastCancer"), "paper_12"),
    (("BRCA1", "BreastCancer"), "curated_panel"),
]);
let witness = evidence
    .why(&("BRCA1", "BreastCancer"))
    .expect("expected explanation");

assert_eq!(witness.len(), 2);
assert!(witness.contains(&"paper_12"));
assert!(witness.contains_token(&"curated_panel"));
assert_eq!(
    witness.iter().copied().collect::<Vec<_>>(),
    vec!["curated_panel", "paper_12"]
);
assert_eq!(witness.to_vec(), vec!["curated_panel", "paper_12"]);

Implementations

impl<P: Ord> ProvenanceSet<P>

pub fn len(&self) -> usize

Returns the number of provenance tokens in the set.

pub fn is_empty(&self) -> bool

Returns true when the provenance set contains no tokens.

pub fn contains(&self, token: &P) -> bool

Returns true when the set contains the given token.

pub fn contains_token(&self, token: &P) -> bool

Returns true when the set contains the given provenance token.

Examples found in repository

examples/provenance.rs (line 29)

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 iter(&self) -> impl Iterator<Item = &P>

Returns an iterator over provenance tokens in deterministic order.

pub fn to_vec(&self) -> Vec<P>

where P: Clone,

Converts the provenance set into a sorted vector of tokens.

Examples found in repository

examples/provenance.rs (line 28)

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/capability_boundaries.rs (line 57)

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()
    );
}

Trait Implementations

impl<P: Clone + Ord> Clone for ProvenanceSet<P>

fn clone(&self) -> ProvenanceSet<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Ord> Debug for ProvenanceSet<P>

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

Formats the value using the given formatter.

impl<P: Ord> Default for ProvenanceSet<P>

fn default() -> Self

Returns the “default value” for a type.

impl<P: PartialEq + Ord> PartialEq for ProvenanceSet<P>

fn eq(&self, other: &ProvenanceSet<P>) -> 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<P: Eq + Ord> Eq for ProvenanceSet<P>

impl<P: Ord> StructuralPartialEq for ProvenanceSet<P>