alice-math 0.1.0

A topology and algebra library from first principles
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use alloc::boxed::Box;
use alloc::collections::BTreeSet;
use crate::core::morphism::Morphism;
use crate::topology::space::TopologicalSpace;

pub struct ContinuousMap<X, Y>
where
    X: TopologicalSpace,
    Y: TopologicalSpace,
{
    f: Box<dyn Fn(&X::Point) -> Y::Point + Send + Sync>,
}

impl<X, Y> ContinuousMap<X, Y>
where
    X: TopologicalSpace,
    Y: TopologicalSpace,
{
    pub fn new<F>(f: F) -> Self
    where
        F: Fn(&X::Point) -> Y::Point + Send + Sync + 'static,
    {
        Self { f: Box::new(f) }
    }

    pub fn apply(&self, p: &X::Point) -> Y::Point {
        (self.f)(p)
    }

    pub fn preimage(
        &self,
        domain_points: &BTreeSet<X::Point>,
        open_set: &BTreeSet<Y::Point>,
    ) -> BTreeSet<X::Point>
    where
        X::Point: Ord,
        Y::Point: Ord,
    {
        domain_points
            .iter()
            .filter(|p| open_set.contains(&self.apply(p)))
            .cloned()
            .collect()
    }

    pub fn is_continuous_on(
        &self,
        domain: &X,
        codomain: &Y,
        domain_points: &BTreeSet<X::Point>,
    ) -> bool
    where
        X::Point: Ord,
        Y::Point: Ord,
        Y: OpenSetsIter,
    {
        for open in codomain.open_sets_iter() {
            let pre = self.preimage(domain_points, &open);
            if !domain.is_open(&pre) {
                return false;
            }
        }
        true
    }
}

impl<X, Y> Morphism for ContinuousMap<X, Y>
where
    X: TopologicalSpace,
    Y: TopologicalSpace,
    X::Point: Clone,
    Y::Point: Clone,
{
    type Domain = X::Point;
    type Codomain = Y::Point;

    fn apply(&self, x: &X::Point) -> Y::Point {
        (self.f)(x)
    }
}

pub trait OpenSetsIter: TopologicalSpace {
    fn open_sets_iter(&self) -> alloc::vec::IntoIter<BTreeSet<Self::Point>>;
}

use crate::topology::space::FiniteTopologicalSpace;

impl<P: Clone + Eq + Ord> OpenSetsIter for FiniteTopologicalSpace<P> {
    fn open_sets_iter(&self) -> alloc::vec::IntoIter<BTreeSet<P>> {
        self.open_sets().iter().cloned().collect::<alloc::vec::Vec<_>>().into_iter()
    }
}