set_theory 1.0.0

//! # Set Laws Unit Tests
//!
//! Comprehensive test suite for set theory law verification.
//!
//! This module tests all standard set theory laws including:
//! - Identity laws
//! - Null/Domination laws
//! - Complement laws
//! - Idempotent laws
//! - Commutative laws
//! - Associative laws
//! - Distributive laws
//! - De Morgan's laws
//! - Absorption laws
//! - Involution laws
//!
//! ## Test Coverage
//!
//! - **Identity Laws**: Union and intersection with identity elements
//! - **Null Laws**: Domination by empty and universal sets
//! - **Complement Laws**: Set and complement relationships
//! - **Algebraic Laws**: Commutative, associative, distributive
//! - **De Morgan's Laws**: Complement of union and intersection
//!
//! ## Running Tests
//!
//! ```bash
//! # Run all laws tests
//! cargo test laws_tests
//!
//! # Run specific law category
//! cargo test laws_tests::test_identity_laws
//! ```
//!
//! ## Theory Reference
//!
//! Based on set laws from:
//! - Discrete Mathematics and Its Applications (Rosen)

use set_theory::laws::SetLaws;
use set_theory::models::CustomSet;

/// Test fixture for set law tests.
///
/// ## Description
///
/// Creates standard test sets used across multiple law verification tests.
///
/// ## Returns
///
/// Tuple of (a, b, c, universal) sets for testing
fn setup_test_sets() -> (
    CustomSet<i32>,
    CustomSet<i32>,
    CustomSet<i32>,
    CustomSet<i32>,
) {
    let a = CustomSet::from(vec![1, 2, 3]);
    let b = CustomSet::from(vec![3, 4, 5]);
    let c = CustomSet::from(vec![5, 6, 7]);
    let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    (a, b, c, universal)
}

// ============================================================================
// IDENTITY LAWS
// ============================================================================

/// Tests identity law for union.
///
/// ## Summary
///
/// Verifies A ∪ ∅ = A.
///
/// ## Law
///
/// Identity Law for Union: A ∪ ∅ = A
///
/// ## Description
///
/// The union of any set with the empty set equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// assert!(SetLaws::identity_union(&a));
/// ```
#[test]
fn test_identity_law_union() {
    let (a, _, _, _) = setup_test_sets();
    assert!(
        SetLaws::identity_union(&a),
        "Identity law for union should hold: A ∪ ∅ = A"
    );
}

/// Tests identity law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ U = A.
///
/// ## Law
///
/// Identity Law for Intersection: A ∩ U = A
///
/// ## Description
///
/// The intersection of any set with the universal set equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// assert!(SetLaws::identity_intersection(&a, &universal));
/// ```
#[test]
fn test_identity_law_intersection() {
    let (a, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::identity_intersection(&a, &universal),
        "Identity law for intersection should hold: A ∩ U = A"
    );
}

// ============================================================================
// NULL/DOMINATION LAWS
// ============================================================================

/// Tests null law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ ∅ = ∅.
///
/// ## Law
///
/// Null/Domination Law for Intersection: A ∩ ∅ = ∅
///
/// ## Description
///
/// The intersection of any set with the empty set equals the empty set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// assert!(SetLaws::null_intersection(&a));
/// ```
#[test]
fn test_null_law_intersection() {
    let (a, _, _, _) = setup_test_sets();
    assert!(
        SetLaws::null_intersection(&a),
        "Null law for intersection should hold: A ∩ ∅ = ∅"
    );
}

/// Tests null law for union.
///
/// ## Summary
///
/// Verifies A ∪ U = U.
///
/// ## Law
///
/// Null/Domination Law for Union: A ∪ U = U
///
/// ## Description
///
/// The union of any set with the universal set equals the universal set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// assert!(SetLaws::null_union(&a, &universal));
/// ```
#[test]
fn test_null_law_union() {
    let (a, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::null_union(&a, &universal),
        "Null law for union should hold: A ∪ U = U"
    );
}

// ============================================================================
// COMPLEMENT LAWS
// ============================================================================

/// Tests complement law for union.
///
/// ## Summary
///
/// Verifies A ∪ A' = U.
///
/// ## Law
///
/// Complement Law for Union: A ∪ A' = U
///
/// ## Description
///
/// The union of a set and its complement equals the universal set.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_complement_law_union() {
    let (a, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::complement_union(&a, &universal),
        "Complement law for union should hold: A ∪ A' = U"
    );
}

/// Tests complement law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ A' = ∅.
///
/// ## Law
///
/// Complement Law for Intersection: A ∩ A' = ∅
///
/// ## Description
///
/// The intersection of a set and its complement equals the empty set.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_complement_law_intersection() {
    let (a, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::complement_intersection(&a, &universal),
        "Complement law for intersection should hold: A ∩ A' = ∅"
    );
}

// ============================================================================
// IDEMPOTENT LAWS
// ============================================================================

/// Tests idempotent law for union.
///
/// ## Summary
///
/// Verifies A ∪ A = A.
///
/// ## Law
///
/// Idempotent Law for Union: A ∪ A = A
///
/// ## Description
///
/// The union of a set with itself equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// assert!(SetLaws::idempotent_union(&a));
/// ```
#[test]
fn test_idempotent_law_union() {
    let (a, _, _, _) = setup_test_sets();
    assert!(
        SetLaws::idempotent_union(&a),
        "Idempotent law for union should hold: A ∪ A = A"
    );
}

/// Tests idempotent law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ A = A.
///
/// ## Law
///
/// Idempotent Law for Intersection: A ∩ A = A
///
/// ## Description
///
/// The intersection of a set with itself equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// assert!(SetLaws::idempotent_intersection(&a));
/// ```
#[test]
fn test_idempotent_law_intersection() {
    let (a, _, _, _) = setup_test_sets();
    assert!(
        SetLaws::idempotent_intersection(&a),
        "Idempotent law for intersection should hold: A ∩ A = A"
    );
}

// ============================================================================
// COMMUTATIVE LAWS
// ============================================================================

/// Tests commutative law for union.
///
/// ## Summary
///
/// Verifies A ∪ B = B ∪ A.
///
/// ## Law
///
/// Commutative Law for Union: A ∪ B = B ∪ A
///
/// ## Description
///
/// The order of sets in a union operation does not matter.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 4, 5]);
/// assert!(SetLaws::commutative_union(&a, &b));
/// ```
#[test]
fn test_commutative_law_union() {
    let (a, b, _, _) = setup_test_sets();
    assert!(
        SetLaws::commutative_union(&a, &b),
        "Commutative law for union should hold: A ∪ B = B ∪ A"
    );
}

/// Tests commutative law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ B = B ∩ A.
///
/// ## Law
///
/// Commutative Law for Intersection: A ∩ B = B ∩ A
///
/// ## Description
///
/// The order of sets in an intersection operation does not matter.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 4, 5]);
/// assert!(SetLaws::commutative_intersection(&a, &b));
/// ```
#[test]
fn test_commutative_law_intersection() {
    let (a, b, _, _) = setup_test_sets();
    assert!(
        SetLaws::commutative_intersection(&a, &b),
        "Commutative law for intersection should hold: A ∩ B = B ∩ A"
    );
}

// ============================================================================
// ASSOCIATIVE LAWS
// ============================================================================

/// Tests associative law for union.
///
/// ## Summary
///
/// Verifies A ∪ (B ∪ C) = (A ∪ B) ∪ C.
///
/// ## Law
///
/// Associative Law for Union: A ∪ (B ∪ C) = (A ∪ B) ∪ C
///
/// ## Description
///
/// The grouping of sets in a union operation does not matter.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_associative_law_union() {
    let (a, b, c, _) = setup_test_sets();
    assert!(
        SetLaws::associative_union(&a, &b, &c),
        "Associative law for union should hold: A ∪ (B ∪ C) = (A ∪ B) ∪ C"
    );
}

/// Tests associative law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ (B ∩ C) = (A ∩ B) ∩ C.
///
/// ## Law
///
/// Associative Law for Intersection: A ∩ (B ∩ C) = (A ∩ B) ∩ C
///
/// ## Description
///
/// The grouping of sets in an intersection operation does not matter.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_associative_law_intersection() {
    let (a, b, c, _) = setup_test_sets();
    assert!(
        SetLaws::associative_intersection(&a, &b, &c),
        "Associative law for intersection should hold: A ∩ (B ∩ C) = (A ∩ B) ∩ C"
    );
}

// ============================================================================
// DISTRIBUTIVE LAWS
// ============================================================================

/// Tests distributive law for union over intersection.
///
/// ## Summary
///
/// Verifies A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C).
///
/// ## Law
///
/// Distributive Law for Union over Intersection: A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C)
///
/// ## Description
///
/// Union distributes over intersection.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_distributive_law_union() {
    let (a, b, c, _) = setup_test_sets();
    assert!(
        SetLaws::distributive_union(&a, &b, &c),
        "Distributive law for union should hold: A ∪ (B ∩ C) = (A ∪ B) ∩ (A ∪ C)"
    );
}

/// Tests distributive law for intersection over union.
///
/// ## Summary
///
/// Verifies A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C).
///
/// ## Law
///
/// Distributive Law for Intersection over Union: A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C)
///
/// ## Description
///
/// Intersection distributes over union.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_distributive_law_intersection() {
    let (a, b, c, _) = setup_test_sets();
    assert!(
        SetLaws::distributive_intersection(&a, &b, &c),
        "Distributive law for intersection should hold: A ∩ (B ∪ C) = (A ∩ B) ∪ (A ∩ C)"
    );
}

// ============================================================================
// DE MORGAN'S LAWS
// ============================================================================

/// Tests De Morgan's law for union.
///
/// ## Summary
///
/// Verifies (A ∪ B)' = A' ∩ B'.
///
/// ## Law
///
/// De Morgan's Law for Union: (A ∪ B)' = A' ∩ B'
///
/// ## Description
///
/// The complement of a union equals the intersection of the complements.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_de_morgan_law_union() {
    let (a, b, _, universal) = setup_test_sets();
    assert!(
        SetLaws::de_morgan_union(&a, &b, &universal),
        "De Morgan's law for union should hold: (A ∪ B)' = A' ∩ B'"
    );
}

/// Tests De Morgan's law for intersection.
///
/// ## Summary
///
/// Verifies (A ∩ B)' = A' ∪ B'.
///
/// ## Law
///
/// De Morgan's Law for Intersection: (A ∩ B)' = A' ∪ B'
///
/// ## Description
///
/// The complement of an intersection equals the union of the complements.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_de_morgan_law_intersection() {
    let (a, b, _, universal) = setup_test_sets();
    assert!(
        SetLaws::de_morgan_intersection(&a, &b, &universal),
        "De Morgan's law for intersection should hold: (A ∩ B)' = A' ∪ B'"
    );
}

// ============================================================================
// ABSORPTION LAWS
// ============================================================================

/// Tests absorption law for union.
///
/// ## Summary
///
/// Verifies A ∪ (A ∩ B) = A.
///
/// ## Law
///
/// Absorption Law for Union: A ∪ (A ∩ B) = A
///
/// ## Description
///
/// The union of a set with its intersection with another set equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 4, 5]);
/// assert!(SetLaws::absorption_union(&a, &b));
/// ```
#[test]
fn test_absorption_law_union() {
    let (a, b, _, _) = setup_test_sets();
    assert!(
        SetLaws::absorption_union(&a, &b),
        "Absorption law for union should hold: A ∪ (A ∩ B) = A"
    );
}

/// Tests absorption law for intersection.
///
/// ## Summary
///
/// Verifies A ∩ (A ∪ B) = A.
///
/// ## Law
///
/// Absorption Law for Intersection: A ∩ (A ∪ B) = A
///
/// ## Description
///
/// The intersection of a set with its union with another set equals the original set.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 4, 5]);
/// assert!(SetLaws::absorption_intersection(&a, &b));
/// ```
#[test]
fn test_absorption_law_intersection() {
    let (a, b, _, _) = setup_test_sets();
    assert!(
        SetLaws::absorption_intersection(&a, &b),
        "Absorption law for intersection should hold: A ∩ (A ∪ B) = A"
    );
}

// ============================================================================
// INVOLUTION LAW
// ============================================================================

/// Tests involution law.
///
/// ## Summary
///
/// Verifies (A')' = A.
///
/// ## Law
///
/// Involution Law: (A')' = A
///
/// ## Description
///
/// The complement of the complement of a set equals the original set.
///
/// ## Examples
///
/// ```rust
/// 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));
/// ```
#[test]
fn test_involution_law() {
    let (a, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::involution(&a, &universal),
        "Involution law should hold: (A')' = A"
    );
}

// ============================================================================
// LAW 0/1
// ============================================================================

/// Tests law 0/1 for empty set complement.
///
/// ## Summary
///
/// Verifies ∅' = U.
///
/// ## Law
///
/// Law 0/1 for Empty Set: ∅' = U
///
/// ## Description
///
/// The complement of the empty set equals the universal set.
///
/// ## Examples
///
/// ```rust
/// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// assert!(SetLaws::law_zero(&universal));
/// ```
#[test]
fn test_law_zero() {
    let (_, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::law_zero(&universal),
        "Law 0/1 for empty set should hold: ∅' = U"
    );
}

/// Tests law 0/1 for universal set complement.
///
/// ## Summary
///
/// Verifies U' = ∅.
///
/// ## Law
///
/// Law 0/1 for Universal Set: U' = ∅
///
/// ## Description
///
/// The complement of the universal set equals the empty set.
///
/// ## Examples
///
/// ```rust
/// let universal = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// assert!(SetLaws::law_one(&universal));
/// ```
#[test]
fn test_law_one() {
    let (_, _, _, universal) = setup_test_sets();
    assert!(
        SetLaws::law_one(&universal),
        "Law 0/1 for universal set should hold: U' = ∅"
    );
}

// ============================================================================
// COMPREHENSIVE LAW VERIFICATION
// ============================================================================

/// Tests all set laws with various test cases.
///
/// ## Summary
///
/// Comprehensive verification of all set laws with multiple test scenarios.
///
/// ## Description
///
/// This test runs all set law verifications to ensure the implementation
/// correctly validates all standard set theory laws.
///
/// ## Examples
///
/// ```rust
/// // All laws should return true for valid sets
/// assert!(SetLaws::identity_union(&a));
/// assert!(SetLaws::commutative_union(&a, &b));
/// assert!(SetLaws::de_morgan_union(&a, &b, &universal));
/// ```
#[test]
fn test_all_set_laws_comprehensive() {
    let (a, b, c, universal) = setup_test_sets();

    // Identity Laws
    assert!(SetLaws::identity_union(&a));
    assert!(SetLaws::identity_intersection(&a, &universal));

    // Null Laws
    assert!(SetLaws::null_intersection(&a));
    assert!(SetLaws::null_union(&a, &universal));

    // Complement Laws
    assert!(SetLaws::complement_union(&a, &universal));
    assert!(SetLaws::complement_intersection(&a, &universal));

    // Idempotent Laws
    assert!(SetLaws::idempotent_union(&a));
    assert!(SetLaws::idempotent_intersection(&a));

    // Involution Law
    assert!(SetLaws::involution(&a, &universal));

    // Absorption Laws
    assert!(SetLaws::absorption_union(&a, &b));
    assert!(SetLaws::absorption_intersection(&a, &b));

    // Commutative Laws
    assert!(SetLaws::commutative_union(&a, &b));
    assert!(SetLaws::commutative_intersection(&a, &b));

    // Associative Laws
    assert!(SetLaws::associative_union(&a, &b, &c));
    assert!(SetLaws::associative_intersection(&a, &b, &c));

    // Distributive Laws
    assert!(SetLaws::distributive_union(&a, &b, &c));
    assert!(SetLaws::distributive_intersection(&a, &b, &c));

    // De Morgan's Laws
    assert!(SetLaws::de_morgan_union(&a, &b, &universal));
    assert!(SetLaws::de_morgan_intersection(&a, &b, &universal));

    // Law 0/1
    assert!(SetLaws::law_zero(&universal));
    assert!(SetLaws::law_one(&universal));
}

/// Tests set laws with edge cases.
///
/// ## Summary
///
/// Verifies set laws hold for edge cases like empty sets.
///
/// ## Description
///
/// Tests that set laws remain valid even with empty sets and other
/// edge cases.
///
/// ## Examples
///
/// ```rust
/// let empty = CustomSet::<i32>::empty();
/// assert!(SetLaws::identity_union(&empty));
/// assert!(SetLaws::idempotent_union(&empty));
/// ```
#[test]
fn test_set_laws_edge_cases() {
    let empty = CustomSet::<i32>::empty();
    let single = CustomSet::from(vec![1]);
    let universal = CustomSet::from(vec![1, 2, 3]);

    // Empty set should satisfy all laws
    assert!(SetLaws::identity_union(&empty));
    assert!(SetLaws::idempotent_union(&empty));
    assert!(SetLaws::idempotent_intersection(&empty));
    assert!(SetLaws::complement_intersection(&empty, &universal));

    // Single element set
    assert!(SetLaws::identity_union(&single));
    assert!(SetLaws::idempotent_union(&single));
}