set_theory 1.0.0

//! # Set Laws Verification
//!
//! Provides verification methods for standard set theory laws.
//!
//! These laws are fundamental identities in set algebra that can be used
//! to prove set equivalences and simplify set expressions.

use std::hash::Hash;

use crate::{CustomSet, SetOperations};

/// Provides verification methods for standard set theory laws.
///
/// Each method returns `true` if the law holds for the given sets.
///
/// # Examples
///
/// ```rust
/// use set_theory::models::CustomSet;
/// use set_theory::laws::SetLaws;
///
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 4, 5]);
///
/// assert!(SetLaws::commutative_union(&a, &b));
/// assert!(SetLaws::de_morgan_union(&a, &b, &CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9])));
/// ```
pub struct SetLaws;

impl SetLaws {
    /// Verifies the Identity Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ ∅ = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// assert!(SetLaws::identity_union(&a));
    /// ```
    pub fn identity_union<T: Eq + Hash + Clone>(a: &CustomSet<T>) -> bool {
        let empty = CustomSet::<T>::empty();
        SetOperations::union(a, &empty).equals(a)
    }

    /// Verifies the Identity Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ U = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
    /// assert!(SetLaws::identity_intersection(&a, &universal));
    /// ```
    pub fn identity_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        universal: &CustomSet<T>,
    ) -> bool {
        SetOperations::intersection(a, universal).equals(a)
    }

    /// Verifies the Null/Domination Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ ∅ = ∅
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// assert!(SetLaws::null_intersection(&a));
    /// ```
    pub fn null_intersection<T: Eq + Hash + Clone>(a: &CustomSet<T>) -> bool {
        let empty = CustomSet::<T>::empty();
        SetOperations::intersection(a, &empty).is_empty()
    }

    /// Verifies the Null/Domination Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ U = U
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
    /// assert!(SetLaws::null_union(&a, &universal));
    /// ```
    pub fn null_union<T: Eq + Hash + Clone>(a: &CustomSet<T>, universal: &CustomSet<T>) -> bool {
        SetOperations::union(a, universal).equals(universal)
    }

    /// Verifies the Complement Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ A' = U
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    /// assert!(SetLaws::complement_union(&a, &universal));
    /// ```
    pub fn complement_union<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        universal: &CustomSet<T>,
    ) -> bool {
        let complement = SetOperations::complement(a, universal);
        SetOperations::union(a, &complement).equals(universal)
    }

    /// Verifies the Complement Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ A' = ∅
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    /// assert!(SetLaws::complement_intersection(&a, &universal));
    /// ```
    pub fn complement_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        universal: &CustomSet<T>,
    ) -> bool {
        let complement = SetOperations::complement(a, universal);
        SetOperations::intersection(a, &complement).is_empty()
    }

    /// Verifies the Idempotent Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ A = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// assert!(SetLaws::idempotent_union(&a));
    /// ```
    pub fn idempotent_union<T: Eq + Hash + Clone>(a: &CustomSet<T>) -> bool {
        SetOperations::union(a, a).equals(a)
    }

    /// Verifies the Idempotent Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ A = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// assert!(SetLaws::idempotent_intersection(&a));
    /// ```
    pub fn idempotent_intersection<T: Eq + Hash + Clone>(a: &CustomSet<T>) -> bool {
        SetOperations::intersection(a, a).equals(a)
    }

    /// Verifies the Involution Law.
    ///
    /// # Law
    ///
    /// (A')' = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    /// assert!(SetLaws::involution(&a, &universal));
    /// ```
    pub fn involution<T: Eq + Hash + Clone>(a: &CustomSet<T>, universal: &CustomSet<T>) -> bool {
        let complement1 = SetOperations::complement(a, universal);
        let complement2 = SetOperations::complement(&complement1, universal);
        complement2.equals(a)
    }

    /// Verifies the Absorption Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ (A ∩ B) = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// assert!(SetLaws::absorption_union(&a, &b));
    /// ```
    pub fn absorption_union<T: Eq + Hash + Clone>(a: &CustomSet<T>, b: &CustomSet<T>) -> bool {
        let intersection = SetOperations::intersection(a, b);
        SetOperations::union(a, &intersection).equals(a)
    }

    /// Verifies the Absorption Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ (A ∪ B) = A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// assert!(SetLaws::absorption_intersection(&a, &b));
    /// ```
    pub fn absorption_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
    ) -> bool {
        let union = SetOperations::union(a, b);
        SetOperations::intersection(a, &union).equals(a)
    }

    /// Verifies the Commutative Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ B = B ∪ A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// assert!(SetLaws::commutative_union(&a, &b));
    /// ```
    pub fn commutative_union<T: Eq + Hash + Clone>(a: &CustomSet<T>, b: &CustomSet<T>) -> bool {
        SetOperations::union(a, b).equals(&SetOperations::union(b, a))
    }

    /// Verifies the Commutative Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ B = B ∩ A
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// assert!(SetLaws::commutative_intersection(&a, &b));
    /// ```
    pub fn commutative_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
    ) -> bool {
        SetOperations::intersection(a, b).equals(&SetOperations::intersection(b, a))
    }

    /// Verifies the Associative Law for Union.
    ///
    /// # Law
    ///
    /// A ∪ (B ∪ C) = (A ∪ B) ∪ C
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let c = CustomSet::from(vec![5, 6, 7]);
    /// assert!(SetLaws::associative_union(&a, &b, &c));
    /// ```
    pub fn associative_union<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        c: &CustomSet<T>,
    ) -> bool {
        let left = SetOperations::union(a, &SetOperations::union(b, c));
        let right = SetOperations::union(&SetOperations::union(a, b), c);
        left.equals(&right)
    }

    /// Verifies the Associative Law for Intersection.
    ///
    /// # Law
    ///
    /// A ∩ (B ∩ C) = (A ∩ B) ∩ C
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let c = CustomSet::from(vec![5, 6, 7]);
    /// assert!(SetLaws::associative_intersection(&a, &b, &c));
    /// ```
    pub fn associative_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        c: &CustomSet<T>,
    ) -> bool {
        let left = SetOperations::intersection(a, &SetOperations::intersection(b, c));
        let right = SetOperations::intersection(&SetOperations::intersection(a, b), c);
        left.equals(&right)
    }

    /// Verifies the Distributive Law for Union over Intersection.
    ///
    /// # Law
    ///
    /// A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C)
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let c = CustomSet::from(vec![5, 6, 7]);
    /// assert!(SetLaws::distributive_union(&a, &b, &c));
    /// ```
    pub fn distributive_union<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        c: &CustomSet<T>,
    ) -> bool {
        let left = SetOperations::union(a, &SetOperations::intersection(b, c));
        let right =
            SetOperations::intersection(&SetOperations::union(a, b), &SetOperations::union(a, c));
        left.equals(&right)
    }

    /// Verifies the Distributive Law for Intersection over Union.
    ///
    /// # Law
    ///
    /// A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C)
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let c = CustomSet::from(vec![5, 6, 7]);
    /// assert!(SetLaws::distributive_intersection(&a, &b, &c));
    /// ```
    pub fn distributive_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        c: &CustomSet<T>,
    ) -> bool {
        let left = SetOperations::intersection(a, &SetOperations::union(b, c));
        let right = SetOperations::union(
            &SetOperations::intersection(a, b),
            &SetOperations::intersection(a, c),
        );
        left.equals(&right)
    }

    /// Verifies De Morgan's Law for Union.
    ///
    /// # Law
    ///
    /// (A ∪ B)' = A' ∩ B'
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    /// assert!(SetLaws::de_morgan_union(&a, &b, &universal));
    /// ```
    pub fn de_morgan_union<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        universal: &CustomSet<T>,
    ) -> bool {
        let union = SetOperations::union(a, b);
        let complement_union = SetOperations::complement(&union, universal);
        let complement_a = SetOperations::complement(a, universal);
        let complement_b = SetOperations::complement(b, universal);
        let intersection_complements = SetOperations::intersection(&complement_a, &complement_b);
        complement_union.equals(&intersection_complements)
    }

    /// Verifies De Morgan's Law for Intersection.
    ///
    /// # Law
    ///
    /// (A ∩ B)' = A' ∪ B'
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let a = CustomSet::from(vec![1, 2, 3]);
    /// let b = CustomSet::from(vec![3, 4, 5]);
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    /// assert!(SetLaws::de_morgan_intersection(&a, &b, &universal));
    /// ```
    pub fn de_morgan_intersection<T: Eq + Hash + Clone>(
        a: &CustomSet<T>,
        b: &CustomSet<T>,
        universal: &CustomSet<T>,
    ) -> bool {
        let intersection = SetOperations::intersection(a, b);
        let complement_intersection = SetOperations::complement(&intersection, universal);
        let complement_a = SetOperations::complement(a, universal);
        let complement_b = SetOperations::complement(b, universal);
        let union_complements = SetOperations::union(&complement_a, &complement_b);
        complement_intersection.equals(&union_complements)
    }

    /// Verifies the Law 0/1 for Empty Set Complement.
    ///
    /// # Law
    ///
    /// ∅' = U
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
    /// assert!(SetLaws::law_zero(&universal));
    /// ```
    pub fn law_zero<T: Eq + Hash + Clone>(universal: &CustomSet<T>) -> bool {
        let empty = CustomSet::<T>::empty();
        SetOperations::complement(&empty, universal).equals(universal)
    }

    /// Verifies the Law 0/1 for Universal Set Complement.
    ///
    /// # Law
    ///
    /// U' = ∅
    ///
    /// # Examples
    ///
    /// ```rust
    /// use set_theory::models::CustomSet;
    /// use set_theory::laws::SetLaws;
    ///
    /// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
    /// assert!(SetLaws::law_one(&universal));
    /// ```
    pub fn law_one<T: Eq + Hash + Clone>(universal: &CustomSet<T>) -> bool {
        SetOperations::complement(universal, universal).is_empty()
    }
}