geometric_rep_theory 0.1.1

Algebraic and geometric structures arising in mathematical physics and mirror symmetry.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::vec;

use crate::toric::cone::RationalPolyhedralCone;
use crate::toric::fan::ToricFan;

impl RationalPolyhedralCone {
    #[must_use = "C^2 cone constructed at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn c2() -> Self {
        RationalPolyhedralCone::new(
            vec![vec![1, 0], vec![0, 1]],
            Some(true),
            Some(2),
            Some(vec![vec![0], vec![1]]),
        )
        .expect("C^2 cone generators are valid and primitive")
    }

    #[must_use = "C^3 cone constructed at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn c3() -> Self {
        RationalPolyhedralCone::new(
            vec![vec![1, 0, 0], vec![0, 1, 0], vec![0, 0, 1]],
            Some(true),
            Some(3),
            Some(vec![vec![0, 1], vec![1, 2], vec![0, 2]]),
        )
        .expect("C^3 cone generators are valid and primitive")
    }
}

impl ToricFan {
    /// The fan of C^2
    #[must_use = "This constructs the C^2 fan at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn c2() -> Self {
        let cone = RationalPolyhedralCone::c2();

        let mut fan = ToricFan::new(2);
        fan.add_cone(cone, true)
            .expect("Single cone always forms a valid fan");
        fan
    }

    /// The fan of C^3
    #[must_use = "This constructs the C^3 fan at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn c3() -> Self {
        let cone = RationalPolyhedralCone::c3();

        let mut fan = ToricFan::new(3);
        fan.add_cone(cone, true)
            .expect("Single cone always forms a valid fan");
        fan
    }

    /// The fan of P^2
    #[must_use = "This constructs the P^2 fan at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn p2() -> Self {
        let c1 = RationalPolyhedralCone::c2();

        let c2 = RationalPolyhedralCone::new(
            vec![vec![0, 1], vec![-1, -1]],
            Some(true),
            Some(2),
            Some(vec![vec![0], vec![1]]),
        )
        .expect("P^2 cone 2 is valid");

        let c3 = RationalPolyhedralCone::new(
            vec![vec![-1, -1], vec![1, 0]],
            Some(true),
            Some(2),
            Some(vec![vec![0], vec![1]]),
        )
        .expect("P^2 cone 3 is valid");

        let mut fan = ToricFan::new(2);
        fan.add_cone(c1, true).expect("P^2 fan condition holds");
        fan.add_cone(c2, false).expect("P^2 fan condition holds");
        fan.add_cone(c3, false).expect("P^2 fan condition holds");
        fan
    }

    #[must_use = "This constructs the Conifold fan at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn conifold() -> Self {
        let c1 = RationalPolyhedralCone::c3();

        let c2 = RationalPolyhedralCone::new(
            vec![vec![1, 0, 0], vec![0, 1, 0], vec![1, 1, -1]],
            Some(true),
            Some(3),
            Some(vec![vec![0, 1], vec![0, 2], vec![1, 2]]),
        )
        .expect("Conifold cone 2 is valid");

        let mut fan = ToricFan::new(3);
        fan.add_cone(c1, true)
            .expect("Conifold fan condition holds");
        fan.add_cone(c2, false)
            .expect("Conifold fan condition holds");
        fan
    }

    #[must_use = "This constructs the Conifold fan at some expense, either use it or avoid calling this method"]
    #[allow(clippy::missing_panics_doc)]
    pub fn conifold2() -> Self {
        let c1 = RationalPolyhedralCone::new(
            vec![vec![1, 0, 0], vec![0, 1, 0], vec![1, 0, 1], vec![0, 1, 1]],
            Some(true),
            Some(3),
            Some(vec![vec![0, 1], vec![0, 2], vec![1, 3], vec![2, 3]]),
        )
        .expect("Conifold cone 1 is valid");

        let mut fan = ToricFan::new(3);
        fan.add_cone(c1, true)
            .expect("Conifold fan condition holds");
        fan
    }

    /// A collection of common example fans
    pub fn common_cases() -> impl Iterator<Item = (String, ToricFan)> {
        [
            Self::c2,
            Self::c3,
            Self::p2,
            Self::conifold,
            Self::conifold2,
        ]
        .into_iter()
        .enumerate()
        .map(|(idx, f)| {
            let name = match idx {
                0 => "C^2",
                1 => "C^3",
                2 => "P^2",
                3 | 4 => "Conifold",
                _ => "Unknown",
            };
            (name.to_string(), f())
        })
    }
}