File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

full_name: MeasureTheory.squareCylinders
code: /-- Given a finite set `s` of indices, a square cylinder is the product of a set `S` of
`∀ i : s, α i` and of `univ` on the other indices. The set `S` is a product of sets `t i` such that
for all `i : s`, `t i ∈ C i`.
`squareCylinders` is the set of all such squareCylinders. -/
def squareCylinders (C : ∀ i, Set (Set (α i))) : Set (Set (∀ i, α i)) 
goal: Set (Set ((i : ι) → α i))

full_name: MeasureTheory.squareCylinders_eq_iUnion_image
code: theorem squareCylinders_eq_iUnion_image (C : ∀ i, Set (Set (α i))) :
    squareCylinders C = ⋃ s : Finset ι, (fun t ↦ (s : Set ι).pi t) '' univ.pi C 
goal: MeasureTheory.squareCylinders C = ⋃ s, (fun t => (↑s).pi t) '' Set.univ.pi C

full_name: MeasureTheory.isPiSystem_squareCylinders
code: theorem isPiSystem_squareCylinders {C : ∀ i, Set (Set (α i))} (hC : ∀ i, IsPiSystem (C i))
    (hC_univ : ∀ i, univ ∈ C i) :
    IsPiSystem (squareCylinders C) 
goal: IsPiSystem (MeasureTheory.squareCylinders C)

full_name: MeasureTheory.comap_eval_le_generateFrom_squareCylinders_singleton
code: theorem comap_eval_le_generateFrom_squareCylinders_singleton
    (α : ι → Type*) [m : ∀ i, MeasurableSpace (α i)] (i : ι) :
    MeasurableSpace.comap (Function.eval i) (m i) ≤
      MeasurableSpace.generateFrom
        ((fun t ↦ ({i} : Set ι).pi t) '' univ.pi fun i ↦ {s : Set (α i) | MeasurableSet s}) 
goal: MeasurableSpace.comap (Function.eval i) (m i) ≤
  MeasurableSpace.generateFrom ((fun t => {i}.pi t) '' Set.univ.pi fun i => {s | MeasurableSet s})

full_name: MeasureTheory.generateFrom_squareCylinders
code: /-- The square cylinders formed from measurable sets generate the product σ-algebra. -/
theorem generateFrom_squareCylinders [∀ i, MeasurableSpace (α i)] :
    MeasurableSpace.generateFrom (squareCylinders fun i ↦ {s : Set (α i) | MeasurableSet s}) =
      MeasurableSpace.pi 
goal: MeasurableSpace.generateFrom (MeasureTheory.squareCylinders fun i => {s | MeasurableSet s}) = MeasurableSpace.pi

full_name: MeasureTheory.cylinder
code: /-- Given a finite set `s` of indices, a cylinder is the preimage of a set `S` of `∀ i : s, α i` by
the projection from `∀ i, α i` to `∀ i : s, α i`. -/
def cylinder (s : Finset ι) (S : Set (∀ i : s, α i)) : Set (∀ i, α i) 
goal: Set ((i : ι) → α i)

full_name: MeasureTheory.mem_cylinder
code: @[simp]
theorem mem_cylinder (s : Finset ι) (S : Set (∀ i : s, α i)) (f : ∀ i, α i) :
    f ∈ cylinder s S ↔ (fun i : s ↦ f i) ∈ S 
goal: f ∈ MeasureTheory.cylinder s S ↔ (fun i => f ↑i) ∈ S

full_name: MeasureTheory.cylinder_empty
code: @[simp]
theorem cylinder_empty (s : Finset ι) : cylinder s (∅ : Set (∀ i : s, α i)) = ∅ 
goal: MeasureTheory.cylinder s ∅ = ∅

full_name: MeasureTheory.cylinder_univ
code: @[simp]
theorem cylinder_univ (s : Finset ι) : cylinder s (univ : Set (∀ i : s, α i)) = univ 
goal: MeasureTheory.cylinder s Set.univ = Set.univ

full_name: MeasureTheory.cylinder_eq_empty_iff
code: @[simp]
theorem cylinder_eq_empty_iff [h_nonempty : Nonempty (∀ i, α i)] (s : Finset ι)
    (S : Set (∀ i : s, α i)) :
    cylinder s S = ∅ ↔ S = ∅ 
goal: MeasureTheory.cylinder s S = ∅ ↔ S = ∅

full_name: MeasureTheory.inter_cylinder
code: theorem inter_cylinder (s₁ s₂ : Finset ι) (S₁ : Set (∀ i : s₁, α i)) (S₂ : Set (∀ i : s₂, α i))
    [DecidableEq ι] :
    cylinder s₁ S₁ ∩ cylinder s₂ S₂ =
      cylinder (s₁ ∪ s₂)
        ((fun f ↦ fun j : s₁ ↦ f ⟨j, Finset.mem_union_left s₂ j.prop⟩) ⁻¹' S₁ ∩
          (fun f ↦ fun j : s₂ ↦ f ⟨j, Finset.mem_union_right s₁ j.prop⟩) ⁻¹' S₂) 
goal: MeasureTheory.cylinder s₁ S₁ ∩ MeasureTheory.cylinder s₂ S₂ =
  MeasureTheory.cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∩ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)

full_name: MeasureTheory.inter_cylinder_same
code: theorem inter_cylinder_same (s : Finset ι) (S₁ : Set (∀ i : s, α i)) (S₂ : Set (∀ i : s, α i)) :
    cylinder s S₁ ∩ cylinder s S₂ = cylinder s (S₁ ∩ S₂) 
goal: MeasureTheory.cylinder s S₁ ∩ MeasureTheory.cylinder s S₂ = MeasureTheory.cylinder s (S₁ ∩ S₂)

full_name: MeasureTheory.union_cylinder
code: theorem union_cylinder (s₁ s₂ : Finset ι) (S₁ : Set (∀ i : s₁, α i)) (S₂ : Set (∀ i : s₂, α i))
    [DecidableEq ι] :
    cylinder s₁ S₁ ∪ cylinder s₂ S₂ =
      cylinder (s₁ ∪ s₂)
        ((fun f ↦ fun j : s₁ ↦ f ⟨j, Finset.mem_union_left s₂ j.prop⟩) ⁻¹' S₁ ∪
          (fun f ↦ fun j : s₂ ↦ f ⟨j, Finset.mem_union_right s₁ j.prop⟩) ⁻¹' S₂) 
goal: MeasureTheory.cylinder s₁ S₁ ∪ MeasureTheory.cylinder s₂ S₂ =
  MeasureTheory.cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)

full_name: MeasureTheory.union_cylinder_same
code: theorem union_cylinder_same (s : Finset ι) (S₁ : Set (∀ i : s, α i)) (S₂ : Set (∀ i : s, α i)) :
    cylinder s S₁ ∪ cylinder s S₂ = cylinder s (S₁ ∪ S₂) 
goal: MeasureTheory.cylinder s S₁ ∪ MeasureTheory.cylinder s S₂ = MeasureTheory.cylinder s (S₁ ∪ S₂)

full_name: MeasureTheory.compl_cylinder
code: theorem compl_cylinder (s : Finset ι) (S : Set (∀ i : s, α i)) :
    (cylinder s S)ᶜ = cylinder s (Sᶜ) 
goal: (MeasureTheory.cylinder s S)ᶜ = MeasureTheory.cylinder s Sᶜ

full_name: MeasureTheory.diff_cylinder_same
code: theorem diff_cylinder_same (s : Finset ι) (S T : Set (∀ i : s, α i)) :
    cylinder s S \ cylinder s T = cylinder s (S \ T) 
goal: MeasureTheory.cylinder s S \ MeasureTheory.cylinder s T = MeasureTheory.cylinder s (S \ T)

full_name: MeasureTheory.eq_of_cylinder_eq_of_subset
code: theorem eq_of_cylinder_eq_of_subset [h_nonempty : Nonempty (∀ i, α i)] {I J : Finset ι}
    {S : Set (∀ i : I, α i)} {T : Set (∀ i : J, α i)} (h_eq : cylinder I S = cylinder J T)
    (hJI : J ⊆ I) :
    S = (fun f : ∀ i : I, α i ↦ fun j : J ↦ f ⟨j, hJI j.prop⟩) ⁻¹' T 
goal: S = (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' T

full_name: MeasureTheory.cylinder_eq_cylinder_union
code: theorem cylinder_eq_cylinder_union [DecidableEq ι] (I : Finset ι) (S : Set (∀ i : I, α i))
    (J : Finset ι) :
    cylinder I S =
      cylinder (I ∪ J) ((fun f ↦ fun j : I ↦ f ⟨j, Finset.mem_union_left J j.prop⟩) ⁻¹' S) 
goal: MeasureTheory.cylinder I S = MeasureTheory.cylinder (I ∪ J) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S)

full_name: MeasureTheory.disjoint_cylinder_iff
code: theorem disjoint_cylinder_iff [Nonempty (∀ i, α i)] {s t : Finset ι} {S : Set (∀ i : s, α i)}
    {T : Set (∀ i : t, α i)} [DecidableEq ι] :
    Disjoint (cylinder s S) (cylinder t T) ↔
      Disjoint
        ((fun f : ∀ i : (s ∪ t : Finset ι), α i
          ↦ fun j : s ↦ f ⟨j, Finset.mem_union_left t j.prop⟩) ⁻¹' S)
        ((fun f ↦ fun j : t ↦ f ⟨j, Finset.mem_union_right s j.prop⟩) ⁻¹' T) 
goal: Disjoint (MeasureTheory.cylinder s S) (MeasureTheory.cylinder t T) ↔
  Disjoint ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' T)

full_name: MeasureTheory.IsClosed.cylinder
code: theorem IsClosed.cylinder [∀ i, TopologicalSpace (α i)] (s : Finset ι) {S : Set (∀ i : s, α i)}
    (hs : IsClosed S) : IsClosed (cylinder s S) 
goal: IsClosed (MeasureTheory.cylinder s S)

full_name: MeasurableSet.cylinder
code: theorem _root_.MeasurableSet.cylinder [∀ i, MeasurableSpace (α i)] (s : Finset ι)
    {S : Set (∀ i : s, α i)} (hS : MeasurableSet S) :
    MeasurableSet (cylinder s S) 
goal: MeasurableSet (MeasureTheory.cylinder s S)

full_name: MeasureTheory.measurableCylinders
code: /-- Given a finite set `s` of indices, a cylinder is the preimage of a set `S` of `∀ i : s, α i` by
the projection from `∀ i, α i` to `∀ i : s, α i`.
`measurableCylinders` is the set of all cylinders with measurable base `S`. -/
def measurableCylinders (α : ι → Type*) [∀ i, MeasurableSpace (α i)] : Set (Set (∀ i, α i)) 
goal: Set (Set ((i : ι) → α i))

full_name: MeasureTheory.empty_mem_measurableCylinders
code: theorem empty_mem_measurableCylinders (α : ι → Type*) [∀ i, MeasurableSpace (α i)] :
    ∅ ∈ measurableCylinders α 
goal: ∅ ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.mem_measurableCylinders
code: @[simp]
theorem mem_measurableCylinders (t : Set (∀ i, α i)) :
    t ∈ measurableCylinders α ↔ ∃ s S, MeasurableSet S ∧ t = cylinder s S 
goal: t ∈ MeasureTheory.measurableCylinders α ↔ ∃ s S, MeasurableSet S ∧ t = MeasureTheory.cylinder s S

full_name: MeasureTheory.measurableCylinders.finset
code: /-- A finset `s` such that `t = cylinder s S`. `S` is given by `measurableCylinders.set`. -/
noncomputable def measurableCylinders.finset (ht : t ∈ measurableCylinders α) : Finset ι 
goal: Finset ι

full_name: MeasureTheory.measurableCylinders.set
code: /-- A set `S` such that `t = cylinder s S`. `s` is given by `measurableCylinders.finset`. -/
def measurableCylinders.set (ht : t ∈ measurableCylinders α) :
    Set (∀ i : measurableCylinders.finset ht, α i) 
goal: Set ((i : { x // x ∈ MeasureTheory.measurableCylinders.finset ht }) → α ↑i)

full_name: MeasureTheory.measurableCylinders.measurableSet
code: theorem measurableCylinders.measurableSet (ht : t ∈ measurableCylinders α) :
    MeasurableSet (measurableCylinders.set ht) 
goal: MeasurableSet (MeasureTheory.measurableCylinders.set ht)

full_name: MeasureTheory.measurableCylinders.eq_cylinder
code: theorem measurableCylinders.eq_cylinder (ht : t ∈ measurableCylinders α) :
    t = cylinder (measurableCylinders.finset ht) (measurableCylinders.set ht) 
goal: t = MeasureTheory.cylinder (MeasureTheory.measurableCylinders.finset ht) (MeasureTheory.measurableCylinders.set ht)

full_name: MeasureTheory.cylinder_mem_measurableCylinders
code: theorem cylinder_mem_measurableCylinders (s : Finset ι) (S : Set (∀ i : s, α i))
    (hS : MeasurableSet S) :
    cylinder s S ∈ measurableCylinders α 
goal: MeasureTheory.cylinder s S ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.inter_mem_measurableCylinders
code: theorem inter_mem_measurableCylinders (hs : s ∈ measurableCylinders α)
    (ht : t ∈ measurableCylinders α) :
    s ∩ t ∈ measurableCylinders α 
goal: s ∩ t ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.isPiSystem_measurableCylinders
code: theorem isPiSystem_measurableCylinders : IsPiSystem (measurableCylinders α) 
goal: IsPiSystem (MeasureTheory.measurableCylinders α)

full_name: MeasureTheory.compl_mem_measurableCylinders
code: theorem compl_mem_measurableCylinders (hs : s ∈ measurableCylinders α) :
    sᶜ ∈ measurableCylinders α 
goal: sᶜ ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.univ_mem_measurableCylinders
code: theorem univ_mem_measurableCylinders (α : ι → Type*) [∀ i, MeasurableSpace (α i)] :
    Set.univ ∈ measurableCylinders α 
goal: Set.univ ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.union_mem_measurableCylinders
code: theorem union_mem_measurableCylinders (hs : s ∈ measurableCylinders α)
    (ht : t ∈ measurableCylinders α) :
    s ∪ t ∈ measurableCylinders α 
goal: s ∪ t ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.diff_mem_measurableCylinders
code: theorem diff_mem_measurableCylinders (hs : s ∈ measurableCylinders α)
    (ht : t ∈ measurableCylinders α) :
    s \ t ∈ measurableCylinders α 
goal: s \ t ∈ MeasureTheory.measurableCylinders α

full_name: MeasureTheory.generateFrom_measurableCylinders
code: /-- The measurable cylinders generate the product σ-algebra. -/
theorem generateFrom_measurableCylinders :
    MeasurableSpace.generateFrom (measurableCylinders α) = MeasurableSpace.pi 
goal: MeasurableSpace.generateFrom (MeasureTheory.measurableCylinders α) = MeasurableSpace.pi