oxilean_std/arithmetic_geometry/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4use super::functions::*;
5
6/// A Chow group CH^n(X) of codimension-n algebraic cycles modulo rational equivalence.
7#[allow(dead_code)]
8#[derive(Debug, Clone)]
9pub struct ChowGroup {
10    /// The algebraic variety X (name).
11    pub variety: String,
12    /// The codimension n.
13    pub codimension: usize,
14    /// A list of generator descriptions.
15    pub generators: Vec<String>,
16}
17#[allow(dead_code)]
18impl ChowGroup {
19    /// Create the Chow group CH^n(X).
20    pub fn new(variety: impl Into<String>, codimension: usize) -> Self {
21        Self {
22            variety: variety.into(),
23            codimension,
24            generators: Vec::new(),
25        }
26    }
27    /// CH^0(X) = Z (free on connected components).
28    pub fn ch0(variety: impl Into<String>) -> Self {
29        let mut g = Self::new(variety, 0);
30        g.generators.push("[X]".to_string());
31        g
32    }
33    /// CH^1(X) = Pic(X), the Picard group.
34    pub fn pic(variety: impl Into<String>) -> Self {
35        let mut g = Self::new(variety, 1);
36        g.generators.push("Pic".to_string());
37        g
38    }
39    /// Add a cycle class generator.
40    pub fn add_generator(&mut self, gen: impl Into<String>) {
41        self.generators.push(gen.into());
42    }
43    /// The intersection product CH^p × CH^q → CH^{p+q} (placeholder).
44    pub fn intersect(&self, other: &Self) -> Self {
45        Self {
46            variety: self.variety.clone(),
47            codimension: self.codimension + other.codimension,
48            generators: vec![format!(
49                "{} · {}",
50                self.generators.first().map(|s| s.as_str()).unwrap_or("?"),
51                other.generators.first().map(|s| s.as_str()).unwrap_or("?")
52            )],
53        }
54    }
55    /// Rank of the Chow group (number of generators in this model).
56    pub fn rank(&self) -> usize {
57        self.generators.len()
58    }
59}
60/// A Berkovich space M(A) represented by a finite list of seminorm data.
61#[allow(dead_code)]
62#[derive(Debug, Clone)]
63pub struct BerkovichSpace {
64    /// The affinoid algebra A (name/description).
65    pub algebra: String,
66    /// The non-archimedean base field K.
67    pub base_field: String,
68    /// Dimension as a topological space (= Krull dim of A).
69    pub dimension: usize,
70    /// Whether this is a smooth Berkovich space.
71    pub is_smooth: bool,
72}
73#[allow(dead_code)]
74impl BerkovichSpace {
75    /// Create a Berkovich space M(A) over K.
76    pub fn new(algebra: impl Into<String>, base_field: impl Into<String>, dim: usize) -> Self {
77        Self {
78            algebra: algebra.into(),
79            base_field: base_field.into(),
80            dimension: dim,
81            is_smooth: false,
82        }
83    }
84    /// The Berkovich unit disc over K: M(K{T}).
85    pub fn unit_disc(base_field: impl Into<String>) -> Self {
86        Self {
87            algebra: "K{T}".to_string(),
88            base_field: base_field.into(),
89            dimension: 1,
90            is_smooth: true,
91        }
92    }
93    /// The Berkovich affine n-space over K: M(K{T_1,...,T_n}).
94    pub fn affine_n_space(base_field: impl Into<String>, n: usize) -> Self {
95        let gens = (1..=n)
96            .map(|i| format!("T_{}", i))
97            .collect::<Vec<_>>()
98            .join(", ");
99        Self {
100            algebra: format!("K{{{}}}", gens),
101            base_field: base_field.into(),
102            dimension: n,
103            is_smooth: true,
104        }
105    }
106    /// The Gauss point (the canonical point in M(K{T})).
107    pub fn gauss_point_description(&self) -> String {
108        format!(
109            "Gauss point of M({}) over {}: seminorm |·|_1",
110            self.algebra, self.base_field
111        )
112    }
113    /// Mark as smooth.
114    pub fn smooth(mut self) -> Self {
115        self.is_smooth = true;
116        self
117    }
118    /// The skeleton (dual graph / tropical variety) description.
119    pub fn skeleton_description(&self) -> String {
120        format!("Skeleton of M({}) (dim ≤ {})", self.algebra, self.dimension)
121    }
122}
123/// Absolute Weil height H(P) on projective space.
124#[derive(Debug, Clone)]
125pub struct AbsoluteHeight {
126    /// Description of the point.
127    pub point_description: String,
128    /// The computed height value.
129    pub value: f64,
130}
131impl AbsoluteHeight {
132    /// Compute the absolute height of a rational number p/q in lowest terms.
133    ///
134    /// H(p/q) = max(|p|, |q|) for [p:q] ∈ P^1(ℚ).
135    pub fn of_rational(p: i64, q: u64) -> Self {
136        let value = (p.unsigned_abs()).max(q) as f64;
137        Self {
138            point_description: format!("{}/{}", p, q),
139            value,
140        }
141    }
142    /// Height of an algebraic number from its minimal polynomial coefficients.
143    pub fn of_minimal_poly(coeffs: &[i64]) -> Self {
144        let max_coeff = coeffs.iter().map(|c| c.unsigned_abs()).max().unwrap_or(0);
145        Self {
146            point_description: format!("root of poly with coeffs {:?}", coeffs),
147            value: max_coeff as f64,
148        }
149    }
150    /// Height value.
151    pub fn value(&self) -> f64 {
152        self.value
153    }
154}
155/// The Langlands correspondence ρ_π ↔ π.
156#[derive(Debug, Clone)]
157pub struct LanglandsCorrespondence {
158    /// The Galois representation.
159    pub galois_rep: GaloisRepresentation,
160    /// The automorphic representation.
161    pub automorphic_rep: AutomorphicRepresentation,
162    /// Which case of Langlands is being invoked.
163    pub correspondence_type: LanglandsType,
164}
165impl LanglandsCorrespondence {
166    /// Create a Langlands correspondence.
167    pub fn new(
168        gal: GaloisRepresentation,
169        aut: AutomorphicRepresentation,
170        kind: LanglandsType,
171    ) -> Self {
172        Self {
173            galois_rep: gal,
174            automorphic_rep: aut,
175            correspondence_type: kind,
176        }
177    }
178}
179/// The Northcott property: finitely many points of bounded height.
180#[derive(Debug, Clone)]
181pub struct NorthcottProperty {
182    /// The space or set satisfying Northcott.
183    pub space: String,
184    /// Whether this is an absolute degree-and-height bound.
185    pub absolute: bool,
186}
187impl NorthcottProperty {
188    /// Projective space P^n satisfies Northcott over any number field.
189    pub fn projective_space(n: usize) -> Self {
190        Self {
191            space: format!("P^{}", n),
192            absolute: true,
193        }
194    }
195    /// Check finitely-many-points-of-bounded-height property for a given bound.
196    ///
197    /// Returns an approximate count estimate for P^1(ℚ) with H ≤ B.
198    pub fn count_estimate_p1_rational(bound: f64) -> usize {
199        if bound < 1.0 {
200            return 0;
201        }
202        ((12.0 / std::f64::consts::PI.powi(2)) * bound * bound).round() as usize
203    }
204}
205/// An abelian variety over a field k of dimension g.
206#[derive(Debug, Clone, PartialEq, Eq)]
207pub struct AbelianVariety {
208    /// The base field (name).
209    pub field: String,
210    /// The dimension g (genus for abelian surfaces g=2, etc.).
211    pub dimension: usize,
212    /// Whether this is a simple abelian variety.
213    pub is_simple: bool,
214    /// Label/name.
215    pub name: String,
216}
217impl AbelianVariety {
218    /// Create an abelian variety over k of dimension g.
219    pub fn new(field: impl Into<String>, dimension: usize) -> Self {
220        Self {
221            field: field.into(),
222            dimension,
223            is_simple: false,
224            name: String::new(),
225        }
226    }
227    /// Named abelian variety.
228    pub fn named(field: impl Into<String>, dimension: usize, name: impl Into<String>) -> Self {
229        Self {
230            field: field.into(),
231            dimension,
232            is_simple: false,
233            name: name.into(),
234        }
235    }
236    /// Dimension of this abelian variety.
237    pub fn dimension(&self) -> usize {
238        self.dimension
239    }
240    /// Rank of the Tate module T_p(A) = 2g.
241    pub fn tate_module_rank(&self) -> usize {
242        2 * self.dimension
243    }
244    /// Trace of Frobenius on T_p(A) (placeholder).
245    pub fn trace_of_frobenius(&self, _prime: u64) -> i64 {
246        0
247    }
248    /// Endomorphism algebra description.
249    pub fn endomorphism_ring(&self) -> String {
250        if self.is_simple {
251            "Division algebra".to_string()
252        } else {
253            "Matrix algebra".to_string()
254        }
255    }
256    /// Mark as simple.
257    pub fn simple(mut self) -> Self {
258        self.is_simple = true;
259        self
260    }
261}
262/// An automorphic representation π = ⊗_v π_v.
263#[derive(Debug, Clone)]
264pub struct AutomorphicRepresentation {
265    /// The reductive group G.
266    pub group: String,
267    /// The number field F.
268    pub field: String,
269    /// The infinitesimal character (weight).
270    pub weight: Vec<i32>,
271    /// Whether this is cuspidal.
272    pub is_cuspidal: bool,
273}
274impl AutomorphicRepresentation {
275    /// Create an automorphic representation of G over F.
276    pub fn new(group: impl Into<String>, field: impl Into<String>) -> Self {
277        Self {
278            group: group.into(),
279            field: field.into(),
280            weight: Vec::new(),
281            is_cuspidal: false,
282        }
283    }
284    /// A classical holomorphic modular form of weight k (automorphic for GL_2).
285    pub fn modular_form_gl2(weight: i32, field: impl Into<String>) -> Self {
286        Self {
287            group: "GL_2".to_string(),
288            field: field.into(),
289            weight: vec![weight],
290            is_cuspidal: true,
291        }
292    }
293    /// Tensor product of local components at a finite set of places.
294    pub fn local_components(&self) -> String {
295        format!("⊗_v π_v of {} over {}", self.group, self.field)
296    }
297}
298/// Type of Langlands correspondence.
299#[derive(Debug, Clone, PartialEq, Eq)]
300pub enum LanglandsType {
301    /// Local Langlands for GL_n (proved by Harris-Taylor and Henniart).
302    LocalGLn,
303    /// Global Langlands for GL_2 over ℚ (class field theory + modular forms).
304    GlobalGL2,
305    /// Functoriality transfer.
306    Functoriality,
307    /// Geometric Langlands.
308    Geometric,
309}
310/// Logarithmic (Weil) height h(P) = log H(P).
311#[derive(Debug, Clone)]
312pub struct LogarithmicHeight {
313    /// The absolute height.
314    pub absolute: AbsoluteHeight,
315}
316impl LogarithmicHeight {
317    /// Create from an absolute height.
318    pub fn from_absolute(h: AbsoluteHeight) -> Self {
319        Self { absolute: h }
320    }
321    /// Compute h(p/q) = log max(|p|, |q|) for [p:q] ∈ P^1(ℚ).
322    pub fn of_rational(p: i64, q: u64) -> Self {
323        Self::from_absolute(AbsoluteHeight::of_rational(p, q))
324    }
325    /// The logarithmic height value.
326    pub fn value(&self) -> f64 {
327        self.absolute.value.ln()
328    }
329}
330/// A condensed abelian group: a sheaf of abelian groups on the category of profinite sets.
331#[allow(dead_code)]
332#[derive(Debug, Clone)]
333pub struct CondensedAbelianGroup {
334    /// Descriptive label (e.g., "R", "Z", "Q/Z").
335    pub label: String,
336    /// Whether this group is solid (satisfies the solid tensor product condition).
337    pub is_solid: bool,
338    /// Whether this is a discrete abelian group (embedded into condensed ab. groups).
339    pub is_discrete: bool,
340}
341#[allow(dead_code)]
342impl CondensedAbelianGroup {
343    /// Wrap a discrete abelian group as a condensed group.
344    pub fn discrete(label: impl Into<String>) -> Self {
345        Self {
346            label: label.into(),
347            is_solid: false,
348            is_discrete: true,
349        }
350    }
351    /// The solid abelian group Z[S] for a profinite set S.
352    pub fn solid_free(profinite_set: impl Into<String>) -> Self {
353        Self {
354            label: format!("Z[{}]^solid", profinite_set.into()),
355            is_solid: true,
356            is_discrete: false,
357        }
358    }
359    /// Mark as solid.
360    pub fn solidify(mut self) -> Self {
361        self.is_solid = true;
362        self
363    }
364    /// The solid tensor product A ⊗_solid B (placeholder returning description).
365    pub fn solid_tensor_product(&self, other: &Self) -> String {
366        format!("{} ⊗_solid {}", self.label, other.label)
367    }
368    /// Check if the group satisfies the liquid vector space condition for exponent p.
369    pub fn is_p_liquid(&self, p: f64) -> bool {
370        self.is_solid && p > 0.0 && p <= 1.0
371    }
372}
373/// A Néron model data record for an abelian variety A over the fraction field of a DVR.
374#[allow(dead_code)]
375#[derive(Debug, Clone)]
376pub struct NeronModel {
377    /// The abelian variety A (name).
378    pub variety: String,
379    /// The discrete valuation ring R (e.g., "Z_p", "O_K").
380    pub dvr: String,
381    /// The fraction field K = Frac(R).
382    pub fraction_field: String,
383    /// Reduction type of the Néron model special fiber.
384    pub reduction_type: NeronReductionType,
385    /// The component group Φ = A_s^0\A_s of the special fiber.
386    pub component_group_order: Option<u64>,
387}
388#[allow(dead_code)]
389impl NeronModel {
390    /// Create a Néron model record.
391    pub fn new(
392        variety: impl Into<String>,
393        dvr: impl Into<String>,
394        fraction_field: impl Into<String>,
395        reduction_type: NeronReductionType,
396    ) -> Self {
397        Self {
398            variety: variety.into(),
399            dvr: dvr.into(),
400            fraction_field: fraction_field.into(),
401            reduction_type,
402            component_group_order: None,
403        }
404    }
405    /// Néron model with good reduction.
406    pub fn good_reduction(
407        variety: impl Into<String>,
408        dvr: impl Into<String>,
409        frac: impl Into<String>,
410    ) -> Self {
411        Self::new(variety, dvr, frac, NeronReductionType::Good)
412    }
413    /// Néron model with semi-stable reduction.
414    pub fn semi_stable(
415        variety: impl Into<String>,
416        dvr: impl Into<String>,
417        frac: impl Into<String>,
418    ) -> Self {
419        Self::new(variety, dvr, frac, NeronReductionType::SemiStable)
420    }
421    /// Set the component group order |Φ|.
422    pub fn with_component_group(mut self, order: u64) -> Self {
423        self.component_group_order = Some(order);
424        self
425    }
426    /// Whether the Néron model has good reduction.
427    pub fn has_good_reduction(&self) -> bool {
428        self.reduction_type == NeronReductionType::Good
429    }
430    /// Whether the Néron model has semi-stable reduction.
431    pub fn is_semi_stable(&self) -> bool {
432        matches!(
433            self.reduction_type,
434            NeronReductionType::Good
435                | NeronReductionType::SemiStable
436                | NeronReductionType::PurelyToric
437        )
438    }
439    /// Tamagawa number c_v = |Φ(k_v)| (number of connected components over residue field).
440    pub fn tamagawa_number(&self) -> u64 {
441        self.component_group_order.unwrap_or(1)
442    }
443}
444/// Reduction type of the special fiber of a Néron model.
445#[allow(dead_code)]
446#[derive(Debug, Clone, PartialEq, Eq)]
447pub enum NeronReductionType {
448    /// Good reduction: A_s is an abelian variety.
449    Good,
450    /// Semi-stable reduction: A_s^0 is a semi-abelian variety.
451    SemiStable,
452    /// Purely toric reduction: A_s^0 is a torus.
453    PurelyToric,
454    /// Additive reduction.
455    Additive,
456}
457/// An elliptic curve E: y² = x³ + ax + b over a field k.
458#[derive(Debug, Clone)]
459pub struct EllipticCurve {
460    /// The base field.
461    pub field: String,
462    /// Coefficient a.
463    pub a: i64,
464    /// Coefficient b.
465    pub b: i64,
466}
467impl EllipticCurve {
468    /// Create an elliptic curve y² = x³ + ax + b.
469    pub fn new(field: impl Into<String>, a: i64, b: i64) -> Self {
470        Self {
471            field: field.into(),
472            a,
473            b,
474        }
475    }
476    /// Discriminant Δ = -16(4a³ + 27b²). Non-zero iff the curve is non-singular.
477    pub fn discriminant(&self) -> i64 {
478        -16 * (4 * self.a.pow(3) + 27 * self.b.pow(2))
479    }
480    /// Whether the curve is non-singular (Δ ≠ 0).
481    pub fn is_non_singular(&self) -> bool {
482        self.discriminant() != 0
483    }
484    /// j-invariant j = -1728 * (4a)³ / Δ (simplified for short Weierstrass).
485    pub fn j_invariant(&self) -> Option<f64> {
486        let delta = self.discriminant();
487        if delta == 0 {
488            return None;
489        }
490        let numerator = -1728.0 * (4.0 * (self.a as f64)).powi(3);
491        Some(numerator / (delta as f64))
492    }
493    /// Check if this is an isomorphism class representative (j-invariant determines it over alg. closed).
494    pub fn j_class(&self) -> String {
495        match self.j_invariant() {
496            Some(j) => format!("j = {:.4}", j),
497            None => "Singular (not an elliptic curve)".to_string(),
498        }
499    }
500}
501/// The p-adic Tate module T_p(A) = lim A[p^n].
502#[derive(Debug, Clone, PartialEq, Eq)]
503pub struct TateModule {
504    /// The abelian variety (name).
505    pub variety: String,
506    /// The prime p.
507    pub prime: u64,
508    /// Rank over ℤ_p (= 2g for an abelian variety of dimension g).
509    pub rank: usize,
510}
511impl TateModule {
512    /// Create T_p(A) for an abelian variety of dimension g.
513    pub fn new(variety: impl Into<String>, prime: u64, dimension: usize) -> Self {
514        Self {
515            variety: variety.into(),
516            prime,
517            rank: 2 * dimension,
518        }
519    }
520}
521/// A Shimura datum (G, X).
522#[derive(Debug, Clone)]
523pub struct ShimuraDatum {
524    /// The reductive group G (name, e.g., "GSp_{2g}", "GL_2", "U(p,q)").
525    pub group: String,
526    /// The hermitian symmetric domain X (e.g., "Siegel upper half-space").
527    pub domain: String,
528    /// The reflex field E(G, X).
529    pub reflex_field: String,
530}
531impl ShimuraDatum {
532    /// Create a Shimura datum.
533    pub fn new(
534        group: impl Into<String>,
535        domain: impl Into<String>,
536        reflex_field: impl Into<String>,
537    ) -> Self {
538        Self {
539            group: group.into(),
540            domain: domain.into(),
541            reflex_field: reflex_field.into(),
542        }
543    }
544    /// The Siegel Shimura datum (GL_2, H): modular curves.
545    pub fn gl2_upper_half_plane() -> Self {
546        Self::new("GL_2", "H (upper half-plane)", "Q")
547    }
548    /// The Siegel Shimura datum (GSp_{2g}, H_g): Siegel modular varieties.
549    pub fn siegel(g: usize) -> Self {
550        Self::new(
551            format!("GSp_{{2{}}}", g),
552            format!("H_{} (Siegel half-space)", g),
553            "Q",
554        )
555    }
556}
557/// Canonical model of a Shimura variety over its reflex field.
558#[derive(Debug, Clone)]
559pub struct CanonicalModel {
560    /// The Shimura variety.
561    pub shimura_variety: ShimuraVariety,
562    /// The reflex field.
563    pub reflex_field: String,
564}
565impl CanonicalModel {
566    /// Create a canonical model.
567    pub fn new(variety: ShimuraVariety, reflex_field: impl Into<String>) -> Self {
568        Self {
569            shimura_variety: variety,
570            reflex_field: reflex_field.into(),
571        }
572    }
573}
574/// A nearly ordinary p-adic Galois representation (Borel reduction at p).
575#[derive(Debug, Clone)]
576pub struct NearlyOrdinaryRepresentation {
577    /// The base representation.
578    pub rep: GaloisRepresentation,
579    /// The prime p at which the representation is nearly ordinary.
580    pub prime: u64,
581}
582impl NearlyOrdinaryRepresentation {
583    /// Create a nearly ordinary representation.
584    pub fn new(rep: GaloisRepresentation, prime: u64) -> Self {
585        Self { rep, prime }
586    }
587}
588/// The canonical Néron-Tate height ĥ: E(K̄) → ℝ.
589#[derive(Debug, Clone)]
590pub struct HeightFunction {
591    /// The elliptic curve.
592    pub curve: String,
593    /// The number field K over which points are defined.
594    pub field: String,
595}
596impl HeightFunction {
597    /// Create the Néron-Tate height for E over K.
598    pub fn neron_tate(curve: impl Into<String>, field: impl Into<String>) -> Self {
599        Self {
600            curve: curve.into(),
601            field: field.into(),
602        }
603    }
604    /// Compute height of a rational point (a/d, b/d²) approximation.
605    ///
606    /// Uses h(x/y) ≈ (1/2) log max(|x|, |y|) as a rough naive height.
607    pub fn naive_height(x_num: i64, x_den: u64) -> f64 {
608        if x_den == 0 {
609            return 0.0;
610        }
611        0.5 * ((x_num.unsigned_abs()).max(x_den) as f64).ln()
612    }
613}
614/// A perfectoid field K with its residue characteristic p.
615#[allow(dead_code)]
616#[derive(Debug, Clone)]
617pub struct PerfectoidField {
618    /// Description of the field (e.g., "C_p", "Q_p^{\infty}").
619    pub name: String,
620    /// Residue characteristic p.
621    pub residue_char: u64,
622    /// Whether the field is algebraically closed (e.g., C_p).
623    pub is_alg_closed: bool,
624    /// Tilt field K^♭ (described by name).
625    pub tilt_name: String,
626}
627#[allow(dead_code)]
628impl PerfectoidField {
629    /// Create a perfectoid field.
630    pub fn new(name: impl Into<String>, residue_char: u64, tilt_name: impl Into<String>) -> Self {
631        Self {
632            name: name.into(),
633            residue_char,
634            is_alg_closed: false,
635            tilt_name: tilt_name.into(),
636        }
637    }
638    /// The completed algebraic closure C_p of Q_p.
639    pub fn c_p(p: u64) -> Self {
640        Self {
641            name: format!("C_{}", p),
642            residue_char: p,
643            is_alg_closed: true,
644            tilt_name: format!("C_{}^flat", p),
645        }
646    }
647    /// The infinite cyclotomic extension Q_p(ζ_{p^∞}).
648    pub fn q_p_cyclotomic(p: u64) -> Self {
649        Self {
650            name: format!("Q_{}(zeta_{{p^inf}})", p),
651            residue_char: p,
652            is_alg_closed: false,
653            tilt_name: format!("F_{}((t^{{1/p^inf}}))", p),
654        }
655    }
656    /// Residue characteristic of this perfectoid field.
657    pub fn residue_characteristic(&self) -> u64 {
658        self.residue_char
659    }
660    /// The tilt K^♭ has characteristic p.
661    pub fn tilt_characteristic(&self) -> u64 {
662        self.residue_char
663    }
664    /// Description of the Hodge-Tate decomposition for a de Rham representation.
665    pub fn hodge_tate_description(&self, dim: usize) -> String {
666        format!(
667            "H^{{}} decomposes over {} as direct sum of dim {} C_p-spaces with Hodge-Tate weights",
668            self.name, dim
669        )
670    }
671}
672/// An isogeny φ: E → E' (group homomorphism with finite kernel).
673#[derive(Debug, Clone)]
674pub struct Isogeny {
675    /// Source elliptic curve.
676    pub source: String,
677    /// Target elliptic curve.
678    pub target: String,
679    /// Degree of the isogeny (= |ker φ|).
680    pub degree: u64,
681}
682impl Isogeny {
683    /// Create an isogeny of the given degree.
684    pub fn new(source: impl Into<String>, target: impl Into<String>, degree: u64) -> Self {
685        Self {
686            source: source.into(),
687            target: target.into(),
688            degree,
689        }
690    }
691    /// The multiplication-by-n map [n]: E → E (isogeny of degree n²).
692    pub fn multiplication_by_n(curve: impl Into<String>, n: u64) -> Self {
693        let c = curve.into();
694        Self {
695            source: c.clone(),
696            target: c,
697            degree: n * n,
698        }
699    }
700    /// Whether this is an endomorphism (source = target).
701    pub fn is_endomorphism(&self) -> bool {
702        self.source == self.target
703    }
704}
705/// The dual abelian variety A^ = Pic^0(A).
706#[derive(Debug, Clone)]
707pub struct DualAbelianVariety {
708    /// The original variety.
709    pub variety: AbelianVariety,
710}
711impl DualAbelianVariety {
712    /// Compute the dual of an abelian variety.
713    pub fn of(variety: AbelianVariety) -> Self {
714        Self { variety }
715    }
716    /// Dimension of the dual variety (same as original).
717    pub fn dimension(&self) -> usize {
718        self.variety.dimension
719    }
720}
721/// A polarized abelian variety: (A, λ) where λ: A → A^ is an isogeny from A to its dual.
722#[derive(Debug, Clone)]
723pub struct PolarizedAbelianVariety {
724    /// The underlying abelian variety.
725    pub variety: AbelianVariety,
726    /// Degree of the polarization λ.
727    pub polarization_degree: u64,
728    /// Whether the polarization is principal (degree 1).
729    pub is_principal: bool,
730}
731impl PolarizedAbelianVariety {
732    /// Create a principally polarized abelian variety.
733    pub fn principally_polarized(variety: AbelianVariety) -> Self {
734        Self {
735            variety,
736            polarization_degree: 1,
737            is_principal: true,
738        }
739    }
740    /// Create a polarized abelian variety with given degree.
741    pub fn polarized(variety: AbelianVariety, degree: u64) -> Self {
742        Self {
743            variety,
744            polarization_degree: degree,
745            is_principal: degree == 1,
746        }
747    }
748}
749/// Data for the Birch and Swinnerton-Dyer conjecture.
750#[derive(Debug, Clone)]
751pub struct BirchSwinnertonDyerData {
752    /// The elliptic curve.
753    pub curve: String,
754    /// Rank of E(ℚ) (Mordell-Weil rank).
755    pub rank: usize,
756    /// Regulator (determinant of the Néron-Tate height pairing matrix).
757    pub regulator: f64,
758    /// Order of the Shafarevich-Tate group (conjectured finite).
759    pub sha_order: Option<u64>,
760    /// Whether BSD rank conjecture is verified for this curve.
761    pub bsd_rank_verified: bool,
762}
763impl BirchSwinnertonDyerData {
764    /// Create BSD data for an elliptic curve.
765    pub fn new(curve: impl Into<String>, rank: usize, regulator: f64) -> Self {
766        Self {
767            curve: curve.into(),
768            rank,
769            regulator,
770            sha_order: None,
771            bsd_rank_verified: false,
772        }
773    }
774    /// BSD formula prediction for the leading coefficient of L(E, s) at s=1.
775    ///
776    /// L^*(E, 1) = (|Sha| · Ω_E · ∏c_p · Reg) / |E(ℚ)_tors|²
777    /// (simplified placeholder).
778    pub fn leading_coefficient_prediction(&self) -> f64 {
779        let sha = self.sha_order.unwrap_or(1) as f64;
780        sha * self.regulator
781    }
782}
783/// A Shimura variety Sh_K(G, X) as a moduli space.
784#[derive(Debug, Clone)]
785pub struct ShimuraVariety {
786    /// The Shimura datum.
787    pub datum: ShimuraDatum,
788    /// The level K (compact open subgroup, described as a string).
789    pub level: String,
790    /// Complex dimension.
791    pub complex_dimension: usize,
792}
793impl ShimuraVariety {
794    /// Create a Shimura variety with the given datum and level.
795    pub fn new(datum: ShimuraDatum, level: impl Into<String>, dim: usize) -> Self {
796        Self {
797            datum,
798            level: level.into(),
799            complex_dimension: dim,
800        }
801    }
802    /// The modular curve Y(N) = Sh_{Γ(N)}(GL_2, H).
803    pub fn modular_curve_y(n: usize) -> Self {
804        Self::new(ShimuraDatum::gl2_upper_half_plane(), format!("Γ({})", n), 1)
805    }
806}
807/// A continuous Galois representation ρ: G_K → GL_n(R).
808#[derive(Debug, Clone)]
809pub struct GaloisRepresentation {
810    /// The Galois group G_K (described by the field K).
811    pub galois_group: String,
812    /// The dimension n.
813    pub dimension: usize,
814    /// The coefficient ring R (e.g., "Z_ell", "Q_ell", "C").
815    pub coefficient_ring: String,
816    /// Whether the representation is irreducible.
817    pub is_irreducible: bool,
818    /// Whether the representation is geometric (de Rham, Hodge-Tate).
819    pub is_geometric: bool,
820}
821impl GaloisRepresentation {
822    /// Create a Galois representation.
823    pub fn new(gal_group: impl Into<String>, dim: usize, ring: impl Into<String>) -> Self {
824        Self {
825            galois_group: gal_group.into(),
826            dimension: dim,
827            coefficient_ring: ring.into(),
828            is_irreducible: false,
829            is_geometric: false,
830        }
831    }
832    /// The ℓ-adic cyclotomic character χ_ℓ: G_ℚ → ℤ_ℓ^×.
833    pub fn cyclotomic(ell: u64) -> Self {
834        let mut r = Self::new("G_Q", 1, format!("Z_{}", ell));
835        r.is_irreducible = true;
836        r.is_geometric = true;
837        r
838    }
839    /// The ℓ-adic Tate module representation of an elliptic curve E.
840    pub fn from_elliptic_curve(curve: &str, ell: u64) -> Self {
841        let mut r = Self::new("G_Q", 2, format!("Z_{}", ell));
842        r.galois_group = format!("G_Q (from {})", curve);
843        r.is_geometric = true;
844        r
845    }
846    /// Mark as irreducible.
847    pub fn irreducible(mut self) -> Self {
848        self.is_irreducible = true;
849        self
850    }
851}
852/// Status record for the André-Oort conjecture (Tolimani's theorem).
853#[derive(Debug, Clone)]
854pub struct TolimaniConjecture {
855    /// Proved under GRH (Klingler-Yafaev, 2014) and unconditionally (Pila-Tsimerman).
856    pub proved: bool,
857    /// Description of the proof method.
858    pub proof_method: String,
859}
860impl TolimaniConjecture {
861    /// The proved André-Oort conjecture.
862    pub fn proved() -> Self {
863        Self {
864            proved: true,
865            proof_method: "o-minimality (Pila-Wilkie) + height bounds".to_string(),
866        }
867    }
868}
869/// The n-torsion subgroup E[n] ⊂ E.
870#[derive(Debug, Clone, PartialEq, Eq)]
871pub struct TorsionPoint {
872    /// The elliptic curve.
873    pub curve: String,
874    /// The torsion order n.
875    pub n: u64,
876    /// Structure: over an algebraically closed field of char 0, E[n] ≅ (ℤ/nℤ)².
877    pub is_full_n_torsion: bool,
878}
879impl TorsionPoint {
880    /// Full n-torsion over an algebraically closed field.
881    pub fn full(curve: impl Into<String>, n: u64) -> Self {
882        Self {
883            curve: curve.into(),
884            n,
885            is_full_n_torsion: true,
886        }
887    }
888    /// Size of the n-torsion group: |E[n]| = n² (over alg. closed field, char 0).
889    pub fn size(&self) -> u64 {
890        if self.is_full_n_torsion {
891            self.n * self.n
892        } else {
893            self.n
894        }
895    }
896}
897/// Faltings's theorem (Mordell conjecture): curves of genus ≥ 2 have finitely many rational points.
898#[derive(Debug, Clone)]
899pub struct FaltingsThm {
900    /// The algebraic curve (name).
901    pub curve: String,
902    /// The genus.
903    pub genus: usize,
904    /// The number field.
905    pub field: String,
906    /// Known rational points.
907    pub known_rational_points: Vec<String>,
908}
909impl FaltingsThm {
910    /// Create a Faltings theorem application for a curve of genus g.
911    pub fn for_curve(curve: impl Into<String>, genus: usize, field: impl Into<String>) -> Self {
912        Self {
913            curve: curve.into(),
914            genus,
915            field: field.into(),
916            known_rational_points: Vec::new(),
917        }
918    }
919    /// Whether finiteness of rational points is guaranteed by Faltings.
920    pub fn finiteness_guaranteed(&self) -> bool {
921        self.genus >= 2
922    }
923    /// Add a known rational point.
924    pub fn add_rational_point(&mut self, point: impl Into<String>) {
925        self.known_rational_points.push(point.into());
926    }
927    /// Fermat curve x^n + y^n = 1 has genus (n-1)(n-2)/2 for n ≥ 3.
928    pub fn fermat_curve(n: usize, field: impl Into<String>) -> Self {
929        let genus = if n >= 3 { (n - 1) * (n - 2) / 2 } else { 0 };
930        Self::for_curve(format!("x^{} + y^{} = 1", n, n), genus, field)
931    }
932}
oxilean_std/arithmetic_geometry/types.rs

oxilean_std/arithmetic_geometry/
types.rs
