File: Mathlib/Algebra/Module/Zlattice/Basic.lean

full_name: Zspan.span_top
code: theorem span_top : span K (span ℤ (Set.range b) : Set E) = ⊤ 
goal: Submodule.span K ↑(Submodule.span ℤ (Set.range ⇑b)) = ⊤

full_name: Zspan.fundamentalDomain
code: /-- The fundamental domain of the ℤ-lattice spanned by `b`. See `Zspan.isAddFundamentalDomain`
for the proof that it is a fundamental domain. -/
def fundamentalDomain : Set E 
goal: Set E

full_name: Zspan.mem_fundamentalDomain
code: @[simp]
theorem mem_fundamentalDomain {m : E} :
    m ∈ fundamentalDomain b ↔ ∀ i, b.repr m i ∈ Set.Ico (0 : K) 1 
goal: m ∈ Zspan.fundamentalDomain b ↔ ∀ (i : ι), (b.repr m) i ∈ Set.Ico 0 1

full_name: Zspan.map_fundamentalDomain
code: theorem map_fundamentalDomain {F : Type*} [NormedAddCommGroup F] [NormedSpace K F] (f : E ≃ₗ[K] F) :
    f '' (fundamentalDomain b) = fundamentalDomain (b.map f) 
goal: ⇑f '' Zspan.fundamentalDomain b = Zspan.fundamentalDomain (b.map f)

full_name: Zspan.fundamentalDomain_reindex
code: @[simp]
theorem fundamentalDomain_reindex {ι' : Type*} (e : ι ≃ ι') :
    fundamentalDomain (b.reindex e) = fundamentalDomain b 
goal: Zspan.fundamentalDomain (b.reindex e) = Zspan.fundamentalDomain b

full_name: Zspan.fundamentalDomain_pi_basisFun
code: lemma fundamentalDomain_pi_basisFun [Fintype ι] :
    fundamentalDomain (Pi.basisFun ℝ ι) = Set.pi Set.univ fun _ : ι ↦ Set.Ico (0 : ℝ) 1 
goal: Zspan.fundamentalDomain (Pi.basisFun ℝ ι) = Set.univ.pi fun x => Set.Ico 0 1

full_name: Zspan.floor
code: /-- The map that sends a vector of `E` to the element of the ℤ-lattice spanned by `b` obtained
by rounding down its coordinates on the basis `b`. -/
def floor (m : E) : span ℤ (Set.range b) 
goal: ↥(Submodule.span ℤ (Set.range ⇑b))

full_name: Zspan.ceil
code: /-- The map that sends a vector of `E` to the element of the ℤ-lattice spanned by `b` obtained
by rounding up its coordinates on the basis `b`. -/
def ceil (m : E) : span ℤ (Set.range b) 
goal: ↥(Submodule.span ℤ (Set.range ⇑b))

full_name: Zspan.repr_floor_apply
code: @[simp]
theorem repr_floor_apply (m : E) (i : ι) : b.repr (floor b m) i = ⌊b.repr m i⌋ 
goal: (b.repr ↑(Zspan.floor b m)) i = ↑⌊(b.repr m) i⌋

full_name: Zspan.repr_ceil_apply
code: @[simp]
theorem repr_ceil_apply (m : E) (i : ι) : b.repr (ceil b m) i = ⌈b.repr m i⌉ 
goal: (b.repr ↑(Zspan.ceil b m)) i = ↑⌈(b.repr m) i⌉

full_name: Zspan.floor_eq_self_of_mem
code: @[simp]
theorem floor_eq_self_of_mem (m : E) (h : m ∈ span ℤ (Set.range b)) : (floor b m : E) = m 
goal: ↑(Zspan.floor b m) = m

full_name: Zspan.ceil_eq_self_of_mem
code: @[simp]
theorem ceil_eq_self_of_mem (m : E) (h : m ∈ span ℤ (Set.range b)) : (ceil b m : E) = m 
goal: ↑(Zspan.ceil b m) = m

full_name: Zspan.fract
code: /-- The map that sends a vector `E` to the `fundamentalDomain` of the lattice,
see `Zspan.fract_mem_fundamentalDomain`, and `fractRestrict` for the map with the codomain
restricted to `fundamentalDomain`. -/
def fract (m : E) : E 
goal: E

full_name: Zspan.fract_apply
code: theorem fract_apply (m : E) : fract b m = m - floor b m 
goal: Zspan.fract b m = m - ↑(Zspan.floor b m)

full_name: Zspan.repr_fract_apply
code: @[simp]
theorem repr_fract_apply (m : E) (i : ι) : b.repr (fract b m) i = Int.fract (b.repr m i) 
goal: (b.repr (Zspan.fract b m)) i = Int.fract ((b.repr m) i)

full_name: Zspan.fract_fract
code: @[simp]
theorem fract_fract (m : E) : fract b (fract b m) = fract b m 
goal: Zspan.fract b (Zspan.fract b m) = Zspan.fract b m

full_name: Zspan.fract_zspan_add
code: @[simp]
theorem fract_zspan_add (m : E) {v : E} (h : v ∈ span ℤ (Set.range b)) :
    fract b (v + m) = fract b m 
goal: Zspan.fract b (v + m) = Zspan.fract b m

full_name: Zspan.fract_add_zspan
code: @[simp]
theorem fract_add_zspan (m : E) {v : E} (h : v ∈ span ℤ (Set.range b)) :
    fract b (m + v) = fract b m 
goal: Zspan.fract b (m + v) = Zspan.fract b m

full_name: Zspan.fract_eq_self
code: theorem fract_eq_self {x : E} : fract b x = x ↔ x ∈ fundamentalDomain b 
goal: Zspan.fract b x = x ↔ x ∈ Zspan.fundamentalDomain b

full_name: Zspan.fract_mem_fundamentalDomain
code: theorem fract_mem_fundamentalDomain (x : E) : fract b x ∈ fundamentalDomain b 
goal: Zspan.fract b x ∈ Zspan.fundamentalDomain b

full_name: Zspan.fractRestrict
code: /-- The map `fract` with codomain restricted to `fundamentalDomain`. -/
def fractRestrict (x : E) : fundamentalDomain b 
goal: ↑(Zspan.fundamentalDomain b)

full_name: Zspan.fractRestrict_surjective
code: theorem fractRestrict_surjective : Function.Surjective (fractRestrict b) 
goal: Function.Surjective (Zspan.fractRestrict b)

full_name: Zspan.fractRestrict_apply
code: @[simp]
theorem fractRestrict_apply (x : E) : (fractRestrict b x : E) = fract b x 
goal: ↑(Zspan.fractRestrict b x) = Zspan.fract b x

full_name: Zspan.fract_eq_fract
code: theorem fract_eq_fract (m n : E) : fract b m = fract b n ↔ -m + n ∈ span ℤ (Set.range b) 
goal: Zspan.fract b m = Zspan.fract b n ↔ -m + n ∈ Submodule.span ℤ (Set.range ⇑b)

full_name: Zspan.norm_fract_le
code: theorem norm_fract_le [HasSolidNorm K] (m : E) : ‖fract b m‖ ≤ ∑ i, ‖b i‖ 
goal: ‖Zspan.fract b m‖ ≤ ∑ i : ι, ‖b i‖

full_name: Zspan.coe_floor_self
code: @[simp]
theorem coe_floor_self (k : K) : (floor (Basis.singleton ι K) k : K) = ⌊k⌋ 
goal: ↑(Zspan.floor (Basis.singleton ι K) k) = ↑⌊k⌋

full_name: Zspan.coe_fract_self
code: @[simp]
theorem coe_fract_self (k : K) : (fract (Basis.singleton ι K) k : K) = Int.fract k 
goal: Zspan.fract (Basis.singleton ι K) k = Int.fract k

full_name: Zspan.fundamentalDomain_isBounded
code: theorem fundamentalDomain_isBounded [Finite ι] [HasSolidNorm K] :
    IsBounded (fundamentalDomain b) 
goal: Bornology.IsBounded (Zspan.fundamentalDomain b)

full_name: Zspan.vadd_mem_fundamentalDomain
code: theorem vadd_mem_fundamentalDomain [Fintype ι] (y : span ℤ (Set.range b)) (x : E) :
    y +ᵥ x ∈ fundamentalDomain b ↔ y = -floor b x 
goal: y +ᵥ x ∈ Zspan.fundamentalDomain b ↔ y = -Zspan.floor b x

full_name: Zspan.exist_unique_vadd_mem_fundamentalDomain
code: theorem exist_unique_vadd_mem_fundamentalDomain [Finite ι] (x : E) :
    ∃! v : span ℤ (Set.range b), v +ᵥ x ∈ fundamentalDomain b 
goal: ∃! v, v +ᵥ x ∈ Zspan.fundamentalDomain b

full_name: Zspan.quotientEquiv
code: /-- The map `Zspan.fractRestrict` defines an equiv map between `E ⧸ span ℤ (Set.range b)`
and `Zspan.fundamentalDomain b`. -/
def quotientEquiv [Fintype ι] :
    E ⧸ span ℤ (Set.range b) ≃ (fundamentalDomain b) 
goal: E ⧸ Submodule.span ℤ (Set.range ⇑b) ≃ ↑(Zspan.fundamentalDomain b)

full_name: Zspan.quotientEquiv_apply_mk
code: @[simp]
theorem quotientEquiv_apply_mk [Fintype ι] (x : E) :
    quotientEquiv b (Submodule.Quotient.mk x) = fractRestrict b x 
goal: (Zspan.quotientEquiv b) (Submodule.Quotient.mk x) = Zspan.fractRestrict b x

full_name: Zspan.quotientEquiv.symm_apply
code: @[simp]
theorem quotientEquiv.symm_apply [Fintype ι] (x : fundamentalDomain b) :
    (quotientEquiv b).symm x = Submodule.Quotient.mk ↑x 
goal: (Zspan.quotientEquiv b).symm x = Submodule.Quotient.mk ↑x

full_name: Zspan.discreteTopology_pi_basisFun
code: theorem discreteTopology_pi_basisFun [Finite ι] :
    DiscreteTopology (span ℤ (Set.range (Pi.basisFun ℝ ι))) 
goal: DiscreteTopology ↥(Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι)))

full_name: Zspan.fundamentalDomain_subset_parallelepiped
code: theorem fundamentalDomain_subset_parallelepiped [Fintype ι] :
    fundamentalDomain b ⊆ parallelepiped b 
goal: Zspan.fundamentalDomain b ⊆ parallelepiped ⇑b

full_name: Zspan.instDiscreteTopologySubtypeMemSubmoduleIntSpanRangeCoeBasisRealOfFinite
code: instance [Finite ι] : DiscreteTopology (span ℤ (Set.range b)) 
goal: DiscreteTopology ↥(Submodule.span ℤ (Set.range ⇑b))

full_name: Zspan.instDiscreteTopologySubtypeMemAddSubgroupToAddSubgroupIntSpanRangeCoeBasisRealOfFinite
code: instance [Finite ι] : DiscreteTopology (span ℤ (Set.range b)).toAddSubgroup 
goal: DiscreteTopology ↥(Submodule.span ℤ (Set.range ⇑b)).toAddSubgroup

full_name: Zspan.fundamentalDomain_measurableSet
code: @[measurability]
theorem fundamentalDomain_measurableSet [MeasurableSpace E] [OpensMeasurableSpace E] [Finite ι] :
    MeasurableSet (fundamentalDomain b) 
goal: MeasurableSet (Zspan.fundamentalDomain b)

full_name: Zspan.isAddFundamentalDomain
code: /-- For a ℤ-lattice `Submodule.span ℤ (Set.range b)`, proves that the set defined
by `Zspan.fundamentalDomain` is a fundamental domain. -/
protected theorem isAddFundamentalDomain [Finite ι] [MeasurableSpace E] [OpensMeasurableSpace E]
    (μ : Measure E) :
    IsAddFundamentalDomain (span ℤ (Set.range b)).toAddSubgroup (fundamentalDomain b) μ 
goal: MeasureTheory.IsAddFundamentalDomain (↥(Submodule.span ℤ (Set.range ⇑b)).toAddSubgroup) (Zspan.fundamentalDomain b) μ

full_name: Zspan.measure_fundamentalDomain_ne_zero
code: theorem measure_fundamentalDomain_ne_zero [Finite ι] [MeasurableSpace E] [BorelSpace E]
    {μ : Measure E} [Measure.IsAddHaarMeasure μ] :
    μ (fundamentalDomain b) ≠ 0 
goal: μ (Zspan.fundamentalDomain b) ≠ 0

full_name: Zspan.measure_fundamentalDomain
code: theorem measure_fundamentalDomain [Fintype ι] [DecidableEq ι] [MeasurableSpace E] (μ : Measure E)
    [BorelSpace E] [Measure.IsAddHaarMeasure μ] (b₀ : Basis ι ℝ E) :
    μ (fundamentalDomain b) = ENNReal.ofReal |b₀.det b| * μ (fundamentalDomain b₀) 
goal: μ (Zspan.fundamentalDomain b) = ENNReal.ofReal |b₀.det ⇑b| * μ (Zspan.fundamentalDomain b₀)

full_name: Zspan.volume_fundamentalDomain
code: @[simp]
theorem volume_fundamentalDomain [Fintype ι] [DecidableEq ι] (b : Basis ι ℝ (ι → ℝ)) :
    volume (fundamentalDomain b) = ENNReal.ofReal |(Matrix.of b).det| 
goal: MeasureTheory.volume (Zspan.fundamentalDomain b) = ENNReal.ofReal |(Matrix.of ⇑b).det|

full_name: Zspan.fundamentalDomain_ae_parallelepiped
code: theorem fundamentalDomain_ae_parallelepiped [Fintype ι] [MeasurableSpace E] (μ : Measure E)
    [BorelSpace E] [Measure.IsAddHaarMeasure μ] :
    fundamentalDomain b =ᵐ[μ] parallelepiped b 
goal: Zspan.fundamentalDomain b =ᵐ[μ] parallelepiped ⇑b

full_name: IsZlattice
code: /-- An `L : Addsubgroup E` where `E` is a vector space over a normed field `K` is a `ℤ`-lattice if
it is discrete and spans `E` over `K`. -/
class IsZlattice (K : Type*) [NormedField K] {E : Type*} [NormedAddCommGroup E] [NormedSpace K E]
    (L : AddSubgroup E) [DiscreteTopology L] : Prop where
  /-- `L` spans the full space `E` over `K`. -/
  span_top : span K (L : Set E) = ⊤
goal: Prop

full_name: IsZlattice.span_top
code: /-- An `L : Addsubgroup E` where `E` is a vector space over a normed field `K` is a `ℤ`-lattice if
it is discrete and spans `E` over `K`. -/
class IsZlattice (K : Type*) [NormedField K] {E : Type*} [NormedAddCommGroup E] [NormedSpace K E]
    (L : AddSubgroup E) [DiscreteTopology L] : Prop where
  /-- `L` spans the full space `E` over `K`. -/
  span_top : span K (L : Set E) = ⊤
goal: Submodule.span K ↑L = ⊤

full_name: Zspan.isZlattice
code: theorem _root_.Zspan.isZlattice {E ι : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [Finite ι] (b : Basis ι ℝ E) :
    IsZlattice ℝ (span ℤ (Set.range b)).toAddSubgroup 
goal: IsZlattice ℝ (Submodule.span ℤ (Set.range ⇑b)).toAddSubgroup

full_name: Zlattice.FG
code: theorem Zlattice.FG [hs : IsZlattice K L] : AddSubgroup.FG L 
goal: L.FG

full_name: Zlattice.module_finite
code: theorem Zlattice.module_finite [IsZlattice K L] : Module.Finite ℤ L 
goal: Module.Finite ℤ ↥L

full_name: instModuleFinite_of_discrete_addSubgroup
code: instance instModuleFinite_of_discrete_addSubgroup {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [FiniteDimensional ℝ E] (L : AddSubgroup E) [DiscreteTopology L] :
    Module.Finite ℤ L 
goal: Module.Finite ℤ ↥L

full_name: Zlattice.module_free
code: theorem Zlattice.module_free [IsZlattice K L] : Module.Free ℤ L 
goal: Module.Free ℤ ↥L

full_name: instModuleFree_of_discrete_addSubgroup
code: instance instModuleFree_of_discrete_addSubgroup {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [FiniteDimensional ℝ E] (L : AddSubgroup E) [DiscreteTopology L] :
    Module.Free ℤ L 
goal: Module.Free ℤ ↥L

full_name: Zlattice.rank
code: theorem Zlattice.rank [hs : IsZlattice K L] : finrank ℤ L = finrank K E 
goal: FiniteDimensional.finrank ℤ ↥L = FiniteDimensional.finrank K E

full_name: Basis.ofZlatticeBasis
code: /-- Any `ℤ`-basis of `L` is also a `K`-basis of `E`. -/
def Basis.ofZlatticeBasis :
    Basis ι K E 
goal: Basis ι K E

full_name: Basis.ofZlatticeBasis_apply
code: @[simp]
theorem Basis.ofZlatticeBasis_apply (i : ι) :
    b.ofZlatticeBasis K L i =  b i 
goal: (Basis.ofZlatticeBasis K L b) i = ↑(b i)

full_name: Basis.ofZlatticeBasis_repr_apply
code: @[simp]
theorem Basis.ofZlatticeBasis_repr_apply (x : L) (i : ι) :
    (b.ofZlatticeBasis K L).repr x i = b.repr x i 
goal: ((Basis.ofZlatticeBasis K L b).repr ↑x) i = ↑((b.repr x) i)

full_name: Basis.ofZlatticeBasis_span
code: theorem Basis.ofZlatticeBasis_span :
    (span ℤ (Set.range (b.ofZlatticeBasis K))).toAddSubgroup = L 
goal: (Submodule.span ℤ (Set.range ⇑(Basis.ofZlatticeBasis K L b))).toAddSubgroup = L

full_name: Zlattice.isAddFundamentalDomain
code: theorem Zlattice.isAddFundamentalDomain {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] {L : AddSubgroup E} [DiscreteTopology L] [IsZlattice ℝ L] [Finite ι]
    (b : Basis ι ℤ L) [MeasurableSpace E] [OpensMeasurableSpace E] (μ : MeasureTheory.Measure E) :
    MeasureTheory.IsAddFundamentalDomain L (Zspan.fundamentalDomain (b.ofZlatticeBasis ℝ)) μ 
goal: MeasureTheory.IsAddFundamentalDomain (↥L) (Zspan.fundamentalDomain (Basis.ofZlatticeBasis ℝ L b)) μ

full_name: instCountable_of_discrete_addSubgroup
code: instance instCountable_of_discrete_addSubgroup {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] (L : AddSubgroup E) [DiscreteTopology L] [IsZlattice ℝ L] :
    Countable L 
goal: Countable ↥L