File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

full_name: hasProd_pi_single
code: @[to_additive]
theorem hasProd_pi_single [DecidableEq β] (b : β) (a : α) : HasProd (Pi.mulSingle b a) a 
goal: HasProd (Pi.mulSingle b a) a

full_name: hasSum_pi_single
code: @[to_additive]
theorem hasProd_pi_single [DecidableEq β] (b : β) (a : α) : HasProd (Pi.mulSingle b a) a 
goal: HasSum (Pi.single b a) a

full_name: tsum_pi_single
code: @[to_additive (attr := simp)]
theorem tprod_pi_single [DecidableEq β] (b : β) (a : α) : ∏' b', Pi.mulSingle b a b' = a 
goal: ∑' (b' : β), Pi.single b a b' = a

full_name: tprod_pi_single
code: @[to_additive (attr := simp)]
theorem tprod_pi_single [DecidableEq β] (b : β) (a : α) : ∏' b', Pi.mulSingle b a b' = a 
goal: ∏' (b' : β), Pi.mulSingle b a b' = a

full_name: tprod_setProd_singleton_left
code: @[to_additive tsum_setProd_singleton_left]
lemma tprod_setProd_singleton_left (b : β) (t : Set γ) (f : β × γ → α) :
    (∏' x : {b} ×ˢ t, f x) = ∏' c : t, f (b, c) 
goal: ∏' (x : ↑({b} ×ˢ t)), f ↑x = ∏' (c : ↑t), f (b, ↑c)

full_name: tsum_setProd_singleton_left
code: @[to_additive tsum_setProd_singleton_left]
lemma tprod_setProd_singleton_left (b : β) (t : Set γ) (f : β × γ → α) :
    (∏' x : {b} ×ˢ t, f x) = ∏' c : t, f (b, c) 
goal: ∑' (x : ↑({b} ×ˢ t)), f ↑x = ∑' (c : ↑t), f (b, ↑c)

full_name: tsum_setProd_singleton_right
code: @[to_additive tsum_setProd_singleton_right]
lemma tprod_setProd_singleton_right (s : Set β) (c : γ) (f : β × γ → α) :
    (∏' x : s ×ˢ {c}, f x) = ∏' b : s, f (b, c) 
goal: ∑' (x : ↑(s ×ˢ {c})), f ↑x = ∑' (b : ↑s), f (↑b, c)

full_name: tprod_setProd_singleton_right
code: @[to_additive tsum_setProd_singleton_right]
lemma tprod_setProd_singleton_right (s : Set β) (c : γ) (f : β × γ → α) :
    (∏' x : s ×ˢ {c}, f x) = ∏' b : s, f (b, c) 
goal: ∏' (x : ↑(s ×ˢ {c})), f ↑x = ∏' (b : ↑s), f (↑b, c)

full_name: Multipliable.prod_symm
code: @[to_additive Summable.prod_symm]
theorem Multipliable.prod_symm {f : β × γ → α} (hf : Multipliable f) :
    Multipliable fun p : γ × β ↦ f p.swap 
goal: Multipliable fun p => f p.swap

full_name: Summable.prod_symm
code: @[to_additive Summable.prod_symm]
theorem Multipliable.prod_symm {f : β × γ → α} (hf : Multipliable f) :
    Multipliable fun p : γ × β ↦ f p.swap 
goal: Summable fun p => f p.swap

full_name: HasProd.prod_mk
code: @[to_additive HasSum.prod_mk]
theorem HasProd.prod_mk {f : β → α} {g : β → γ} {a : α} {b : γ}
    (hf : HasProd f a) (hg : HasProd g b) : HasProd (fun x ↦ (⟨f x, g x⟩ : α × γ)) ⟨a, b⟩ 
goal: HasProd (fun x => (f x, g x)) (a, b)

full_name: HasSum.prod_mk
code: @[to_additive HasSum.prod_mk]
theorem HasProd.prod_mk {f : β → α} {g : β → γ} {a : α} {b : γ}
    (hf : HasProd f a) (hg : HasProd g b) : HasProd (fun x ↦ (⟨f x, g x⟩ : α × γ)) ⟨a, b⟩ 
goal: HasSum (fun x => (f x, g x)) (a, b)

full_name: HasProd.sigma
code: @[to_additive]
theorem HasProd.sigma {γ : β → Type*} {f : (Σ b : β, γ b) → α} {g : β → α} {a : α}
    (ha : HasProd f a) (hf : ∀ b, HasProd (fun c ↦ f ⟨b, c⟩) (g b)) : HasProd g a 
goal: HasProd g a

full_name: HasSum.sigma
code: @[to_additive]
theorem HasProd.sigma {γ : β → Type*} {f : (Σ b : β, γ b) → α} {g : β → α} {a : α}
    (ha : HasProd f a) (hf : ∀ b, HasProd (fun c ↦ f ⟨b, c⟩) (g b)) : HasProd g a 
goal: HasSum g a

full_name: HasProd.prod_fiberwise
code: /-- If a function `f` on `β × γ` has product `a` and for each `b` the restriction of `f` to
`{b} × γ` has product `g b`, then the function `g` has product `a`. -/
@[to_additive HasSum.prod_fiberwise "If a series `f` on `β × γ` has sum `a` and for each `b` the
restriction of `f` to `{b} × γ` has sum `g b`, then the series `g` has sum `a`."]
theorem HasProd.prod_fiberwise {f : β × γ → α} {g : β → α} {a : α} (ha : HasProd f a)
    (hf : ∀ b, HasProd (fun c ↦ f (b, c)) (g b)) : HasProd g a 
goal: HasProd g a

full_name: HasSum.prod_fiberwise
code: /-- If a function `f` on `β × γ` has product `a` and for each `b` the restriction of `f` to
`{b} × γ` has product `g b`, then the function `g` has product `a`. -/
@[to_additive HasSum.prod_fiberwise "If a series `f` on `β × γ` has sum `a` and for each `b` the
restriction of `f` to `{b} × γ` has sum `g b`, then the series `g` has sum `a`."]
theorem HasProd.prod_fiberwise {f : β × γ → α} {g : β → α} {a : α} (ha : HasProd f a)
    (hf : ∀ b, HasProd (fun c ↦ f (b, c)) (g b)) : HasProd g a 
goal: HasSum g a

full_name: Summable.sigma'
code: @[to_additive]
theorem Multipliable.sigma' {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f)
    (hf : ∀ b, Multipliable fun c ↦ f ⟨b, c⟩) : Multipliable fun b ↦ ∏' c, f ⟨b, c⟩ 
goal: Summable fun b => ∑' (c : γ b), f ⟨b, c⟩

full_name: Multipliable.sigma'
code: @[to_additive]
theorem Multipliable.sigma' {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f)
    (hf : ∀ b, Multipliable fun c ↦ f ⟨b, c⟩) : Multipliable fun b ↦ ∏' c, f ⟨b, c⟩ 
goal: Multipliable fun b => ∏' (c : γ b), f ⟨b, c⟩

full_name: HasProd.sigma_of_hasProd
code: @[to_additive]
theorem HasProd.sigma_of_hasProd {γ : β → Type*} {f : (Σb : β, γ b) → α} {g : β → α}
    {a : α} (ha : HasProd g a) (hf : ∀ b, HasProd (fun c ↦ f ⟨b, c⟩) (g b)) (hf' : Multipliable f) :
    HasProd f a 
goal: HasProd f a

full_name: HasSum.sigma_of_hasSum
code: @[to_additive]
theorem HasProd.sigma_of_hasProd {γ : β → Type*} {f : (Σb : β, γ b) → α} {g : β → α}
    {a : α} (ha : HasProd g a) (hf : ∀ b, HasProd (fun c ↦ f ⟨b, c⟩) (g b)) (hf' : Multipliable f) :
    HasProd f a 
goal: HasSum f a

full_name: tsum_sigma'
code: @[to_additive]
theorem tprod_sigma' {γ : β → Type*} {f : (Σb : β, γ b) → α}
    (h₁ : ∀ b, Multipliable fun c ↦ f ⟨b, c⟩) (h₂ : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∑' (p : (b : β) × γ b), f p = ∑' (b : β) (c : γ b), f ⟨b, c⟩

full_name: tprod_sigma'
code: @[to_additive]
theorem tprod_sigma' {γ : β → Type*} {f : (Σb : β, γ b) → α}
    (h₁ : ∀ b, Multipliable fun c ↦ f ⟨b, c⟩) (h₂ : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∏' (p : (b : β) × γ b), f p = ∏' (b : β) (c : γ b), f ⟨b, c⟩

full_name: tprod_prod'
code: @[to_additive tsum_prod']
theorem tprod_prod' {f : β × γ → α} (h : Multipliable f)
    (h₁ : ∀ b, Multipliable fun c ↦ f (b, c)) :
    ∏' p, f p = ∏' (b) (c), f (b, c) 
goal: ∏' (p : β × γ), f p = ∏' (b : β) (c : γ), f (b, c)

full_name: tsum_prod'
code: @[to_additive tsum_prod']
theorem tprod_prod' {f : β × γ → α} (h : Multipliable f)
    (h₁ : ∀ b, Multipliable fun c ↦ f (b, c)) :
    ∏' p, f p = ∏' (b) (c), f (b, c) 
goal: ∑' (p : β × γ), f p = ∑' (b : β) (c : γ), f (b, c)

full_name: tprod_comm'
code: @[to_additive]
theorem tprod_comm' {f : β → γ → α} (h : Multipliable (Function.uncurry f))
    (h₁ : ∀ b, Multipliable (f b)) (h₂ : ∀ c, Multipliable fun b ↦ f b c) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c 
goal: ∏' (c : γ) (b : β), f b c = ∏' (b : β) (c : γ), f b c

full_name: tsum_comm'
code: @[to_additive]
theorem tprod_comm' {f : β → γ → α} (h : Multipliable (Function.uncurry f))
    (h₁ : ∀ b, Multipliable (f b)) (h₂ : ∀ c, Multipliable fun b ↦ f b c) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c 
goal: ∑' (c : γ) (b : β), f b c = ∑' (b : β) (c : γ), f b c

full_name: Summable.sigma_factor
code: @[to_additive]
theorem Multipliable.sigma_factor {γ : β → Type*} {f : (Σb : β, γ b) → α}
    (ha : Multipliable f) (b : β) :
    Multipliable fun c ↦ f ⟨b, c⟩ 
goal: Summable fun c => f ⟨b, c⟩

full_name: Multipliable.sigma_factor
code: @[to_additive]
theorem Multipliable.sigma_factor {γ : β → Type*} {f : (Σb : β, γ b) → α}
    (ha : Multipliable f) (b : β) :
    Multipliable fun c ↦ f ⟨b, c⟩ 
goal: Multipliable fun c => f ⟨b, c⟩

full_name: Multipliable.sigma
code: @[to_additive]
theorem Multipliable.sigma {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f) :
    Multipliable fun b ↦ ∏' c, f ⟨b, c⟩ 
goal: Multipliable fun b => ∏' (c : γ b), f ⟨b, c⟩

full_name: Summable.sigma
code: @[to_additive]
theorem Multipliable.sigma {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f) :
    Multipliable fun b ↦ ∏' c, f ⟨b, c⟩ 
goal: Summable fun b => ∑' (c : γ b), f ⟨b, c⟩

full_name: Multipliable.prod_factor
code: @[to_additive Summable.prod_factor]
theorem Multipliable.prod_factor {f : β × γ → α} (h : Multipliable f) (b : β) :
    Multipliable fun c ↦ f (b, c) 
goal: Multipliable fun c => f (b, c)

full_name: Summable.prod_factor
code: @[to_additive Summable.prod_factor]
theorem Multipliable.prod_factor {f : β × γ → α} (h : Multipliable f) (b : β) :
    Multipliable fun c ↦ f (b, c) 
goal: Summable fun c => f (b, c)

full_name: HasProd.tprod_fiberwise
code: @[to_additive]
lemma HasProd.tprod_fiberwise [T2Space α] {f : β → α} {a : α} (hf : HasProd f a) (g : β → γ) :
    HasProd (fun c : γ ↦ ∏' b : g ⁻¹' {c}, f b) a 
goal: HasProd (fun c => ∏' (b : ↑(g ⁻¹' {c})), f ↑b) a

full_name: HasSum.tsum_fiberwise
code: @[to_additive]
lemma HasProd.tprod_fiberwise [T2Space α] {f : β → α} {a : α} (hf : HasProd f a) (g : β → γ) :
    HasProd (fun c : γ ↦ ∏' b : g ⁻¹' {c}, f b) a 
goal: HasSum (fun c => ∑' (b : ↑(g ⁻¹' {c})), f ↑b) a

full_name: tprod_sigma
code: @[to_additive]
theorem tprod_sigma {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∏' (p : (b : β) × γ b), f p = ∏' (b : β) (c : γ b), f ⟨b, c⟩

full_name: tsum_sigma
code: @[to_additive]
theorem tprod_sigma {γ : β → Type*} {f : (Σb : β, γ b) → α} (ha : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∑' (p : (b : β) × γ b), f p = ∑' (b : β) (c : γ b), f ⟨b, c⟩

full_name: tprod_prod
code: @[to_additive tsum_prod]
theorem tprod_prod {f : β × γ → α} (h : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∏' (p : β × γ), f p = ∏' (b : β) (c : γ), f (b, c)

full_name: tsum_prod
code: @[to_additive tsum_prod]
theorem tprod_prod {f : β × γ → α} (h : Multipliable f) :
    ∏' p, f p = ∏' (b) (c), f ⟨b, c⟩ 
goal: ∑' (p : β × γ), f p = ∑' (b : β) (c : γ), f (b, c)

full_name: tprod_comm
code: @[to_additive]
theorem tprod_comm {f : β → γ → α} (h : Multipliable (Function.uncurry f)) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c 
goal: ∏' (c : γ) (b : β), f b c = ∏' (b : β) (c : γ), f b c

full_name: tsum_comm
code: @[to_additive]
theorem tprod_comm {f : β → γ → α} (h : Multipliable (Function.uncurry f)) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c 
goal: ∑' (c : γ) (b : β), f b c = ∑' (b : β) (c : γ), f b c

full_name: Pi.hasSum
code: @[to_additive]
theorem Pi.hasProd {f : ι → ∀ x, π x} {g : ∀ x, π x} :
    HasProd f g ↔ ∀ x, HasProd (fun i ↦ f i x) (g x) 
goal: HasSum f g ↔ ∀ (x : α), HasSum (fun i => f i x) (g x)

full_name: Pi.hasProd
code: @[to_additive]
theorem Pi.hasProd {f : ι → ∀ x, π x} {g : ∀ x, π x} :
    HasProd f g ↔ ∀ x, HasProd (fun i ↦ f i x) (g x) 
goal: HasProd f g ↔ ∀ (x : α), HasProd (fun i => f i x) (g x)

full_name: Pi.multipliable
code: @[to_additive]
theorem Pi.multipliable {f : ι → ∀ x, π x} : Multipliable f ↔ ∀ x, Multipliable fun i ↦ f i x 
goal: Multipliable f ↔ ∀ (x : α), Multipliable fun i => f i x

full_name: Pi.summable
code: @[to_additive]
theorem Pi.multipliable {f : ι → ∀ x, π x} : Multipliable f ↔ ∀ x, Multipliable fun i ↦ f i x 
goal: Summable f ↔ ∀ (x : α), Summable fun i => f i x

full_name: tsum_apply
code: @[to_additive]
theorem tprod_apply [∀ x, T2Space (π x)] {f : ι → ∀ x, π x} {x : α} (hf : Multipliable f) :
    (∏' i, f i) x = ∏' i, f i x 
goal: tsum (fun i => f i) x = ∑' (i : ι), f i x

full_name: tprod_apply
code: @[to_additive]
theorem tprod_apply [∀ x, T2Space (π x)] {f : ι → ∀ x, π x} {x : α} (hf : Multipliable f) :
    (∏' i, f i) x = ∏' i, f i x 
goal: tprod (fun i => f i) x = ∏' (i : ι), f i x

full_name: HasSum.op
code: theorem HasSum.op (hf : HasSum f a) : HasSum (fun a ↦ op (f a)) (op a) 
goal: HasSum (fun a => MulOpposite.op (f a)) (MulOpposite.op a)

full_name: Summable.op
code: theorem Summable.op (hf : Summable f) : Summable (op ∘ f) 
goal: Summable (MulOpposite.op ∘ f)

full_name: HasSum.unop
code: theorem HasSum.unop {f : β → αᵐᵒᵖ} {a : αᵐᵒᵖ} (hf : HasSum f a) :
    HasSum (fun a ↦ unop (f a)) (unop a) 
goal: HasSum (fun a => MulOpposite.unop (f a)) (MulOpposite.unop a)

full_name: Summable.unop
code: theorem Summable.unop {f : β → αᵐᵒᵖ} (hf : Summable f) : Summable (unop ∘ f) 
goal: Summable (MulOpposite.unop ∘ f)

full_name: hasSum_op
code: @[simp]
theorem hasSum_op : HasSum (fun a ↦ op (f a)) (op a) ↔ HasSum f a 
goal: HasSum (fun a => MulOpposite.op (f a)) (MulOpposite.op a) ↔ HasSum f a

full_name: hasSum_unop
code: @[simp]
theorem hasSum_unop {f : β → αᵐᵒᵖ} {a : αᵐᵒᵖ} :
    HasSum (fun a ↦ unop (f a)) (unop a) ↔ HasSum f a 
goal: HasSum (fun a => MulOpposite.unop (f a)) (MulOpposite.unop a) ↔ HasSum f a

full_name: summable_op
code: @[simp]
theorem summable_op : (Summable fun a ↦ op (f a)) ↔ Summable f 
goal: (Summable fun a => MulOpposite.op (f a)) ↔ Summable f

full_name: summable_unop
code: @[simp low]
theorem summable_unop {f : β → αᵐᵒᵖ} : (Summable fun a ↦ unop (f a)) ↔ Summable f 
goal: (Summable fun a => MulOpposite.unop (f a)) ↔ Summable f

full_name: tsum_op
code: theorem tsum_op [T2Space α] :
    ∑' x, op (f x) = op (∑' x, f x) 
goal: ∑' (x : β), MulOpposite.op (f x) = MulOpposite.op (∑' (x : β), f x)

full_name: tsum_unop
code: theorem tsum_unop [T2Space α] {f : β → αᵐᵒᵖ} :
    ∑' x, unop (f x) = unop (∑' x, f x) 
goal: ∑' (x : β), MulOpposite.unop (f x) = MulOpposite.unop (∑' (x : β), f x)

full_name: HasSum.star
code: theorem HasSum.star (h : HasSum f a) : HasSum (fun b ↦ star (f b)) (star a) 
goal: HasSum (fun b => star (f b)) (star a)

full_name: Summable.star
code: theorem Summable.star (hf : Summable f) : Summable fun b ↦ star (f b) 
goal: Summable fun b => star (f b)

full_name: Summable.ofStar
code: theorem Summable.ofStar (hf : Summable fun b ↦ Star.star (f b)) : Summable f 
goal: Summable f

full_name: summable_star_iff
code: @[simp]
theorem summable_star_iff : (Summable fun b ↦ star (f b)) ↔ Summable f 
goal: (Summable fun b => star (f b)) ↔ Summable f

full_name: summable_star_iff'
code: @[simp]
theorem summable_star_iff' : Summable (star f) ↔ Summable f 
goal: Summable (star f) ↔ Summable f

full_name: tsum_star
code: theorem tsum_star [T2Space α] : star (∑' b, f b) = ∑' b, star (f b) 
goal: star (∑' (b : β), f b) = ∑' (b : β), star (f b)