[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Order.Monovary).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
lemma monovary_iff_forall_smul_nonneg : Monovary f g ↔ ∀ i j, 0 ≤ (f j - f i) • (g j - g i)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Order.Monovary.monovaryOn_inv_left (L38-L40)
lemma monovaryOn_inv_left : MonovaryOn f⁻¹ g s ↔ AntivaryOn f g s
```

-- snippet 2
```lean
-- Mathlib.Algebra.Order.Monovary.antivaryOn_inv_left (L42-L44)
lemma antivaryOn_inv_left : AntivaryOn f⁻¹ g s ↔ MonovaryOn f g s
```

-- snippet 3
```lean
-- Mathlib.Algebra.Order.Monovary.Monovary (L70-L72)
lemma Monovary.mul_left (h₁ : Monovary f₁ g) (h₂ : Monovary f₂ g) : Monovary (f₁ * f₂) g
```

-- snippet 4
```lean
-- Mathlib.Algebra.Order.Monovary.Antivary (L74-L76)
lemma Antivary.mul_left (h₁ : Antivary f₁ g) (h₂ : Antivary f₂ g) : Antivary (f₁ * f₂) g
```

-- snippet 5
```lean
-- Mathlib.Algebra.Order.Monovary.Monovary (L78-L80)
lemma Monovary.div_left (h₁ : Monovary f₁ g) (h₂ : Antivary f₂ g) : Monovary (f₁ / f₂) g
```

-- snippet 6
```lean
-- Mathlib.Algebra.Order.Monovary.Antivary (L82-L84)
lemma Antivary.div_left (h₁ : Antivary f₁ g) (h₂ : Monovary f₂ g) : Antivary (f₁ / f₂) g
```

-- snippet 7
```lean
-- Mathlib.Algebra.Order.Monovary.monovaryOn_inv_right (L98-L100)
lemma monovaryOn_inv_right : MonovaryOn f g⁻¹ s ↔ AntivaryOn f g s
```

-- snippet 8
```lean
-- Mathlib.Algebra.Order.Monovary.antivaryOn_inv_right (L102-L104)
lemma antivaryOn_inv_right : AntivaryOn f g⁻¹ s ↔ MonovaryOn f g s
```

-- snippet 9
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.subadditiveHomClass (L68-L70)
instance subadditiveHomClass : SubadditiveHomClass (AbsoluteValue R S) R S
```

-- snippet 10
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.nonnegHomClass (L65-L67)
instance nonnegHomClass : NonnegHomClass (AbsoluteValue R S) R S
```

-- snippet 11
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.mulHomClass (L62-L64)
instance mulHomClass : MulHomClass (AbsoluteValue R S) R S
```

-- snippet 12
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.funLike (L55-L58)
instance funLike : FunLike (AbsoluteValue R S) R S where
  coe f
```

-- snippet 13
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.coe_mk (L72-L74)
theorem coe_mk (f : R →ₙ* S) {h₁ h₂ h₃} : (AbsoluteValue.mk f h₁ h₂ h₃ : R → S) = f
```

-- snippet 14
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.zeroHomClass (L59-L61)
instance zeroHomClass : ZeroHomClass (AbsoluteValue R S) R S where
  map_zero f
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Order.Monovary).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
lemma monovary_iff_forall_smul_nonneg : Monovary f g ↔ ∀ i j, 0 ≤ (f j - f i) • (g j - g i)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Order.Monovary.monovaryOn_inv_left (L38-L40)
lemma monovaryOn_inv_left : MonovaryOn f⁻¹ g s ↔ AntivaryOn f g s
```

-- snippet 2
```lean
-- Mathlib.Algebra.Order.Monovary.antivaryOn_inv_left (L42-L44)
lemma antivaryOn_inv_left : AntivaryOn f⁻¹ g s ↔ MonovaryOn f g s
```

-- snippet 3
```lean
-- Mathlib.Algebra.Order.Monovary.Monovary (L70-L72)
lemma Monovary.mul_left (h₁ : Monovary f₁ g) (h₂ : Monovary f₂ g) : Monovary (f₁ * f₂) g
```

-- snippet 4
```lean
-- Mathlib.Algebra.Order.Monovary.Antivary (L74-L76)
lemma Antivary.mul_left (h₁ : Antivary f₁ g) (h₂ : Antivary f₂ g) : Antivary (f₁ * f₂) g
```

-- snippet 5
```lean
-- Mathlib.Algebra.Order.Monovary.Monovary (L78-L80)
lemma Monovary.div_left (h₁ : Monovary f₁ g) (h₂ : Antivary f₂ g) : Monovary (f₁ / f₂) g
```

-- snippet 6
```lean
-- Mathlib.Algebra.Order.Monovary.Antivary (L82-L84)
lemma Antivary.div_left (h₁ : Antivary f₁ g) (h₂ : Monovary f₂ g) : Antivary (f₁ / f₂) g
```

-- snippet 7
```lean
-- Mathlib.Algebra.Order.Monovary.monovaryOn_inv_right (L98-L100)
lemma monovaryOn_inv_right : MonovaryOn f g⁻¹ s ↔ AntivaryOn f g s
```

-- snippet 8
```lean
-- Mathlib.Algebra.Order.Monovary.antivaryOn_inv_right (L102-L104)
lemma antivaryOn_inv_right : AntivaryOn f g⁻¹ s ↔ MonovaryOn f g s
```

-- snippet 9
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.subadditiveHomClass (L68-L70)
instance subadditiveHomClass : SubadditiveHomClass (AbsoluteValue R S) R S
```

-- snippet 10
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.nonnegHomClass (L65-L67)
instance nonnegHomClass : NonnegHomClass (AbsoluteValue R S) R S
```

-- snippet 11
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.mulHomClass (L62-L64)
instance mulHomClass : MulHomClass (AbsoluteValue R S) R S
```

-- snippet 12
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.funLike (L55-L58)
instance funLike : FunLike (AbsoluteValue R S) R S where
  coe f
```

-- snippet 13
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.coe_mk (L72-L74)
theorem coe_mk (f : R →ₙ* S) {h₁ h₂ h₃} : (AbsoluteValue.mk f h₁ h₂ h₃ : R → S) = f
```

-- snippet 14
```lean
-- Mathlib.Algebra.Order.AbsoluteValue.Basic.zeroHomClass (L59-L61)
instance zeroHomClass : ZeroHomClass (AbsoluteValue R S) R S where
  map_zero f
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.Algebra.InfiniteSum.Defs).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem tprod_eq_one_of_not_multipliable (h : ¬Multipliable f L) : ∏'[L] b, f b = 1
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.HasProd (L106-L110)
def HasProd (f : β → α) (a : α) (L
```

-- snippet 2
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Multipliable (L114-L116)
def Multipliable (f : β → α) (L
```

-- snippet 3
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Multipliable (L118-L131)
lemma Multipliable.mono_filter {f : β → α} {L₁ L₂ : SummationFilter β}
    (hf : Multipliable f L₂) (h : L₁.filter ≤ L₂.filter) : Multipliable f L₁
```

-- snippet 4
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.hasProd_bot (L163-L168)
lemma hasProd_bot (hL : ¬L.NeBot) (f : β → α) (a : α) :
    HasProd f a L
```

-- snippet 5
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.multipliable_bot (L170-L178)
lemma multipliable_bot (hL : ¬L.NeBot) (f : β → α) :
    Multipliable f L
```

-- snippet 6
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.tprod_bot (L184-L195)
lemma tprod_bot (hL : ¬L.NeBot) (f : β → α) : ∏'[L] b, f b = ∏ᶠ b, f b
```

-- snippet 7
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.HasProd (L197-L199)
theorem HasProd.multipliable (h : HasProd f a L) : Multipliable f L
```

-- snippet 8
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Function (L205-L208)
theorem Function.Injective.hasProd_map_iff {L : SummationFilter γ} {g : γ → β} (hg : Injective g) :
    HasProd f a (L.map ⟨g, hg⟩) ↔ HasProd (f ∘ g) a L
```

-- snippet 9
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_isOpenMap (L146-L152)
theorem homothety_isOpenMap (x : P) (t : R) (ht : t ≠ 0) : IsOpenMap <| homothety x t
```

-- snippet 10
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_continuous (L118-L125)
theorem homothety_continuous (x : P) (t : R) : Continuous <| homothety x t
```

-- snippet 11
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous (L66-L75)
theorem lineMap_continuous {p q : P} :
    Continuous (lineMap p q : R →ᵃ[R] P)
```

-- snippet 12
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous_uncurry (L60-L65)
theorem lineMap_continuous_uncurry :
    Continuous (fun pqt : P × P × R ↦ lineMap pqt.1 pqt.2.1 pqt.2.2)
```

-- snippet 13
```lean
-- Mathlib.Topology.Algebra.Affine.isOpenMap_linear_iff (L46-L58)
theorem isOpenMap_linear_iff {f : P →ᵃ[R] Q} : IsOpenMap f.linear ↔ IsOpenMap f
```

-- snippet 14
```lean
-- Mathlib.Topology.Algebra.Affine.continuous_linear_iff (L35-L45)
theorem continuous_linear_iff {f : P →ᵃ[R] Q} : Continuous f.linear ↔ Continuous f
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.Algebra.InfiniteSum.Defs).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem tprod_eq_one_of_not_multipliable (h : ¬Multipliable f L) : ∏'[L] b, f b = 1
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.HasProd (L106-L110)
def HasProd (f : β → α) (a : α) (L
```

-- snippet 2
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Multipliable (L114-L116)
def Multipliable (f : β → α) (L
```

-- snippet 3
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Multipliable (L118-L131)
lemma Multipliable.mono_filter {f : β → α} {L₁ L₂ : SummationFilter β}
    (hf : Multipliable f L₂) (h : L₁.filter ≤ L₂.filter) : Multipliable f L₁
```

-- snippet 4
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.hasProd_bot (L163-L168)
lemma hasProd_bot (hL : ¬L.NeBot) (f : β → α) (a : α) :
    HasProd f a L
```

-- snippet 5
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.multipliable_bot (L170-L178)
lemma multipliable_bot (hL : ¬L.NeBot) (f : β → α) :
    Multipliable f L
```

-- snippet 6
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.tprod_bot (L184-L195)
lemma tprod_bot (hL : ¬L.NeBot) (f : β → α) : ∏'[L] b, f b = ∏ᶠ b, f b
```

-- snippet 7
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.HasProd (L197-L199)
theorem HasProd.multipliable (h : HasProd f a L) : Multipliable f L
```

-- snippet 8
```lean
-- Mathlib.Topology.Algebra.InfiniteSum.Defs.Function (L205-L208)
theorem Function.Injective.hasProd_map_iff {L : SummationFilter γ} {g : γ → β} (hg : Injective g) :
    HasProd f a (L.map ⟨g, hg⟩) ↔ HasProd (f ∘ g) a L
```

-- snippet 9
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_isOpenMap (L146-L152)
theorem homothety_isOpenMap (x : P) (t : R) (ht : t ≠ 0) : IsOpenMap <| homothety x t
```

-- snippet 10
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_continuous (L118-L125)
theorem homothety_continuous (x : P) (t : R) : Continuous <| homothety x t
```

-- snippet 11
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous (L66-L75)
theorem lineMap_continuous {p q : P} :
    Continuous (lineMap p q : R →ᵃ[R] P)
```

-- snippet 12
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous_uncurry (L60-L65)
theorem lineMap_continuous_uncurry :
    Continuous (fun pqt : P × P × R ↦ lineMap pqt.1 pqt.2.1 pqt.2.2)
```

-- snippet 13
```lean
-- Mathlib.Topology.Algebra.Affine.isOpenMap_linear_iff (L46-L58)
theorem isOpenMap_linear_iff {f : P →ᵃ[R] Q} : IsOpenMap f.linear ↔ IsOpenMap f
```

-- snippet 14
```lean
-- Mathlib.Topology.Algebra.Affine.continuous_linear_iff (L35-L45)
theorem continuous_linear_iff {f : P →ᵃ[R] Q} : Continuous f.linear ↔ Continuous f
```
[/INST]

mistral-common:Tekken v15 (Mistral chat template, [INST]/[SYSTEM_PROMPT])


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Asymptotics.TVS).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem IsBigOTVS.neg_right (h : f =O[𝕜; l] g) : f =O[𝕜; l] (-g)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsThetaTVS (L120-L122)
def IsThetaTVS (l : Filter α) (f : α → E) (g : α → F) : Prop
```

-- snippet 2
```lean
-- Mathlib.Analysis.Asymptotics.TVS.isLittleOTVS_iff_tendsto_div (L141-L151)
theorem isLittleOTVS_iff_tendsto_div :
    f =o[𝕜; l] g ↔ ∀ U ∈ 𝓝 0, ∃ V ∈ 𝓝 0,
      Tendsto (fun x ↦ egauge 𝕜 U (f x) / egauge 𝕜 V (g x)) l (𝓝 0)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L152-L159)
theorem IsLittleOTVS.exists_eventuallyLE_mul_ennreal (h : f =o[𝕜; l] g) {U : Set E} (hU : U ∈ 𝓝 0) :
    ∃ V ∈ 𝓝 (0 : F), ∀ ε ≠ 0, (fun x ↦ egauge 𝕜 U (f x)) ≤ᶠ[l] (fun x ↦ ε * egauge 𝕜 V (g x))
```

-- snippet 4
```lean
-- Mathlib.Analysis.Asymptotics.TVS.isLittleOTVS_congr (L160-L167)
theorem isLittleOTVS_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    f₁ =o[𝕜; l] g₁ ↔ f₂ =o[𝕜; l] g₂
```

-- snippet 5
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L168-L171)
theorem IsLittleOTVS.congr' (h : f₁ =o[𝕜; l] g₁) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    f₂ =o[𝕜; l] g₂
```

-- snippet 6
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L172-L175)
theorem IsLittleOTVS.congr (h : f₁ =o[𝕜; l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =o[𝕜; l] g₂
```

-- snippet 7
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L176-L178)
theorem IsLittleOTVS.congr_left (h : f₁ =o[𝕜; l] g) (hf : ∀ x, f₁ x = f₂ x) : f₂ =o[𝕜; l] g
```

-- snippet 8
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L179-L181)
theorem IsLittleOTVS.congr_right (h : f =o[𝕜; l] g₁) (hg : ∀ x, g₁ x = g₂ x) : f =o[𝕜; l] g₂
```

-- snippet 9
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.IsLittleO (L153-L155)
theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w
```

-- snippet 10
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_iff_exists_eq_mul (L181-L191)
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
```

-- snippet 11
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_zero_iff_isBigO_zero (L114-L118)
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
```

-- snippet 12
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.IsEquivalent (L73-L77)
theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v
```

-- snippet 13
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_const_iff_tendsto (L119-L128)
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c)
```

-- snippet 14
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_zero_iff_eventually_zero (L110-L113)
theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Asymptotics.TVS).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem IsBigOTVS.neg_right (h : f =O[𝕜; l] g) : f =O[𝕜; l] (-g)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsThetaTVS (L120-L122)
def IsThetaTVS (l : Filter α) (f : α → E) (g : α → F) : Prop
```

-- snippet 2
```lean
-- Mathlib.Analysis.Asymptotics.TVS.isLittleOTVS_iff_tendsto_div (L141-L151)
theorem isLittleOTVS_iff_tendsto_div :
    f =o[𝕜; l] g ↔ ∀ U ∈ 𝓝 0, ∃ V ∈ 𝓝 0,
      Tendsto (fun x ↦ egauge 𝕜 U (f x) / egauge 𝕜 V (g x)) l (𝓝 0)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L152-L159)
theorem IsLittleOTVS.exists_eventuallyLE_mul_ennreal (h : f =o[𝕜; l] g) {U : Set E} (hU : U ∈ 𝓝 0) :
    ∃ V ∈ 𝓝 (0 : F), ∀ ε ≠ 0, (fun x ↦ egauge 𝕜 U (f x)) ≤ᶠ[l] (fun x ↦ ε * egauge 𝕜 V (g x))
```

-- snippet 4
```lean
-- Mathlib.Analysis.Asymptotics.TVS.isLittleOTVS_congr (L160-L167)
theorem isLittleOTVS_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    f₁ =o[𝕜; l] g₁ ↔ f₂ =o[𝕜; l] g₂
```

-- snippet 5
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L168-L171)
theorem IsLittleOTVS.congr' (h : f₁ =o[𝕜; l] g₁) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    f₂ =o[𝕜; l] g₂
```

-- snippet 6
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L172-L175)
theorem IsLittleOTVS.congr (h : f₁ =o[𝕜; l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =o[𝕜; l] g₂
```

-- snippet 7
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L176-L178)
theorem IsLittleOTVS.congr_left (h : f₁ =o[𝕜; l] g) (hf : ∀ x, f₁ x = f₂ x) : f₂ =o[𝕜; l] g
```

-- snippet 8
```lean
-- Mathlib.Analysis.Asymptotics.TVS.IsLittleOTVS (L179-L181)
theorem IsLittleOTVS.congr_right (h : f =o[𝕜; l] g₁) (hg : ∀ x, g₁ x = g₂ x) : f =o[𝕜; l] g₂
```

-- snippet 9
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.IsLittleO (L153-L155)
theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w
```

-- snippet 10
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_iff_exists_eq_mul (L181-L191)
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
```

-- snippet 11
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_zero_iff_isBigO_zero (L114-L118)
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
```

-- snippet 12
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.IsEquivalent (L73-L77)
theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v
```

-- snippet 13
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_const_iff_tendsto (L119-L128)
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c)
```

-- snippet 14
```lean
-- Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.isEquivalent_zero_iff_eventually_zero (L110-L113)
theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Homology.ShortComplex.Limits).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
instance hasColimitsOfShape :
    HasColimitsOfShape J (ShortComplex C) where

noncomputable instance : PreservesColimitsOfShape J (π₁ : _ ⥤ C) where

noncomputable instance : PreservesColimitsOfShape J (π₂ : _ ⥤ C) where

noncomputable instance : PreservesColimitsOfShape J (π₃ : _ ⥤ C) where
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.isLimitOfIsLimitπ (L34-L61)
def isLimitOfIsLimitπ (c : Cone F)
    (h₁ : IsLimit (π₁.mapCone c)) (h₂ : IsLimit (π₂.mapCone c))
    (h₃ : IsLimit (π₃.mapCone c)) : IsLimit c where
  lift s
```

-- snippet 2
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasLimit_of_hasLimitπ (L98-L108)
instance hasLimit_of_hasLimitπ : HasLimit F
```

-- snippet 3
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasLimitsOfShape (L115-L123)
instance hasLimitsOfShape :
    HasLimitsOfShape J (ShortComplex C) where

noncomputable instance : PreservesLimitsOfShape J (π₁ : _ ⥤ C) where

noncomputable instance : PreservesLimitsOfShape J (π₂ : _ ⥤ C) where

noncomputable instance : PreservesLimitsOfShape J (π₃ : _ ⥤ C) where
```

-- snippet 4
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasFiniteLimits (L130-L141)
instance hasFiniteLimits : HasFiniteLimits (ShortComplex C)
```

-- snippet 5
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₁ (L148-L151)
instance preservesMonomorphisms_π₁ :
    Functor.PreservesMonomorphisms (π₁ : _ ⥤ C)
```

-- snippet 6
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₂ (L152-L155)
instance preservesMonomorphisms_π₂ :
    Functor.PreservesMonomorphisms (π₂ : _ ⥤ C)
```

-- snippet 7
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₃ (L156-L159)
instance preservesMonomorphisms_π₃ :
    Functor.PreservesMonomorphisms (π₃ : _ ⥤ C)
```

-- snippet 8
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.isColimitOfIsColimitπ (L164-L195)
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s
```

-- snippet 9
```lean
-- Mathlib.Algebra.Homology.Additive.hasIntScalar (L53-L57)
instance hasIntScalar : SMul ℤ (C ⟶ D)
```

-- snippet 10
```lean
-- Mathlib.Algebra.Homology.Additive.zero_f_apply (L59-L61)
theorem zero_f_apply (i : ι) : (0 : C ⟶ D).f i = 0
```

-- snippet 11
```lean
-- Mathlib.Algebra.Homology.Additive.sub_f_apply (L71-L73)
theorem sub_f_apply (f g : C ⟶ D) (i : ι) : (f - g).f i = f.f i - g.f i
```

-- snippet 12
```lean
-- Mathlib.Algebra.Homology.Additive.neg_f_apply (L67-L69)
theorem neg_f_apply (f : C ⟶ D) (i : ι) : (-f).f i = -f.f i
```

-- snippet 13
```lean
-- Mathlib.Algebra.Homology.Additive.hasNatScalar (L48-L52)
instance hasNatScalar : SMul ℕ (C ⟶ D)
```

-- snippet 14
```lean
-- Mathlib.Algebra.Homology.Additive.add_f_apply (L63-L65)
theorem add_f_apply (f g : C ⟶ D) (i : ι) : (f + g).f i = f.f i + g.f i
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Homology.ShortComplex.Limits).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
instance hasColimitsOfShape :
    HasColimitsOfShape J (ShortComplex C) where

noncomputable instance : PreservesColimitsOfShape J (π₁ : _ ⥤ C) where

noncomputable instance : PreservesColimitsOfShape J (π₂ : _ ⥤ C) where

noncomputable instance : PreservesColimitsOfShape J (π₃ : _ ⥤ C) where
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.isLimitOfIsLimitπ (L34-L61)
def isLimitOfIsLimitπ (c : Cone F)
    (h₁ : IsLimit (π₁.mapCone c)) (h₂ : IsLimit (π₂.mapCone c))
    (h₃ : IsLimit (π₃.mapCone c)) : IsLimit c where
  lift s
```

-- snippet 2
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasLimit_of_hasLimitπ (L98-L108)
instance hasLimit_of_hasLimitπ : HasLimit F
```

-- snippet 3
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasLimitsOfShape (L115-L123)
instance hasLimitsOfShape :
    HasLimitsOfShape J (ShortComplex C) where

noncomputable instance : PreservesLimitsOfShape J (π₁ : _ ⥤ C) where

noncomputable instance : PreservesLimitsOfShape J (π₂ : _ ⥤ C) where

noncomputable instance : PreservesLimitsOfShape J (π₃ : _ ⥤ C) where
```

-- snippet 4
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.hasFiniteLimits (L130-L141)
instance hasFiniteLimits : HasFiniteLimits (ShortComplex C)
```

-- snippet 5
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₁ (L148-L151)
instance preservesMonomorphisms_π₁ :
    Functor.PreservesMonomorphisms (π₁ : _ ⥤ C)
```

-- snippet 6
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₂ (L152-L155)
instance preservesMonomorphisms_π₂ :
    Functor.PreservesMonomorphisms (π₂ : _ ⥤ C)
```

-- snippet 7
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.preservesMonomorphisms_π₃ (L156-L159)
instance preservesMonomorphisms_π₃ :
    Functor.PreservesMonomorphisms (π₃ : _ ⥤ C)
```

-- snippet 8
```lean
-- Mathlib.Algebra.Homology.ShortComplex.Limits.isColimitOfIsColimitπ (L164-L195)
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s
```

-- snippet 9
```lean
-- Mathlib.Algebra.Homology.Additive.hasIntScalar (L53-L57)
instance hasIntScalar : SMul ℤ (C ⟶ D)
```

-- snippet 10
```lean
-- Mathlib.Algebra.Homology.Additive.zero_f_apply (L59-L61)
theorem zero_f_apply (i : ι) : (0 : C ⟶ D).f i = 0
```

-- snippet 11
```lean
-- Mathlib.Algebra.Homology.Additive.sub_f_apply (L71-L73)
theorem sub_f_apply (f g : C ⟶ D) (i : ι) : (f - g).f i = f.f i - g.f i
```

-- snippet 12
```lean
-- Mathlib.Algebra.Homology.Additive.neg_f_apply (L67-L69)
theorem neg_f_apply (f : C ⟶ D) (i : ι) : (-f).f i = -f.f i
```

-- snippet 13
```lean
-- Mathlib.Algebra.Homology.Additive.hasNatScalar (L48-L52)
instance hasNatScalar : SMul ℕ (C ⟶ D)
```

-- snippet 14
```lean
-- Mathlib.Algebra.Homology.Additive.add_f_apply (L63-L65)
theorem add_f_apply (f g : C ⟶ D) (i : ι) : (f + g).f i = f.f i + g.f i
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.OpenPartialHomeomorph.Defs).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem eq_symm_apply {x : X} {y : Y} (hx : x ∈ e.source) (hy : y ∈ e.target) :
    x = e.symm y ↔ e x = y
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.Simps (L88-L90)
def Simps.apply (e : OpenPartialHomeomorph X Y) : X → Y
```

-- snippet 2
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.Simps (L91-L97)
def Simps.symm_apply (e : OpenPartialHomeomorph X Y) : Y → X
```

-- snippet 3
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.continuousOn_symm (L98-L100)
theorem continuousOn_symm : ContinuousOn e.symm e.target
```

-- snippet 4
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.mk_coe (L102-L105)
theorem mk_coe (e : PartialEquiv X Y) (a b c d) :
    (OpenPartialHomeomorph.mk e a b c d : X → Y) = e
```

-- snippet 5
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.mk_coe_symm (L107-L110)
theorem mk_coe_symm (e : PartialEquiv X Y) (a b c d) :
    ((OpenPartialHomeomorph.mk e a b c d).symm : Y → X) = e.symm
```

-- snippet 6
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.toPartialEquiv_injective (L111-L116)
theorem toPartialEquiv_injective :
    Injective (toPartialEquiv : OpenPartialHomeomorph X Y → PartialEquiv X Y)
  | ⟨_, _, _, _, _⟩, ⟨_, _, _, _, _⟩, rfl => rfl

/- Register a few simp lemmas to make sure that `simp` puts the application of a local
homeomorphism in its normal form, i.e., in terms of its coercion to a function. -/
```

-- snippet 7
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.toFun_eq_coe (L118-L120)
theorem toFun_eq_coe (e : OpenPartialHomeomorph X Y) : e.toFun = e
```

-- snippet 8
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.invFun_eq_coe (L122-L124)
theorem invFun_eq_coe (e : OpenPartialHomeomorph X Y) : e.invFun = e.symm
```

-- snippet 9
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_source_inter_eq' (L54-L56)
theorem image_source_inter_eq' (s : Set X) : e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' s
```

-- snippet 10
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_source_inter_eq (L57-L60)
theorem image_source_inter_eq (s : Set X) :
    e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' (e.source ∩ s)
```

-- snippet 11
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.refl_partialEquiv (L38-L40)
theorem refl_partialEquiv : (OpenPartialHomeomorph.refl X).toPartialEquiv = PartialEquiv.refl X
```

-- snippet 12
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_eq_target_inter_inv_preimage (L50-L53)
theorem image_eq_target_inter_inv_preimage {s : Set X} (h : s ⊆ e.source) :
    e '' s = e.target ∩ e.symm ⁻¹' s
```

-- snippet 13
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.refl_symm (L42-L46)
theorem refl_symm : (OpenPartialHomeomorph.refl X).symm = OpenPartialHomeomorph.refl X
```

-- snippet 14
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.source_preimage_target (L47-L49)
theorem source_preimage_target : e.source ⊆ e ⁻¹' e.target
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.OpenPartialHomeomorph.Defs).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem eq_symm_apply {x : X} {y : Y} (hx : x ∈ e.source) (hy : y ∈ e.target) :
    x = e.symm y ↔ e x = y
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.Simps (L88-L90)
def Simps.apply (e : OpenPartialHomeomorph X Y) : X → Y
```

-- snippet 2
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.Simps (L91-L97)
def Simps.symm_apply (e : OpenPartialHomeomorph X Y) : Y → X
```

-- snippet 3
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.continuousOn_symm (L98-L100)
theorem continuousOn_symm : ContinuousOn e.symm e.target
```

-- snippet 4
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.mk_coe (L102-L105)
theorem mk_coe (e : PartialEquiv X Y) (a b c d) :
    (OpenPartialHomeomorph.mk e a b c d : X → Y) = e
```

-- snippet 5
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.mk_coe_symm (L107-L110)
theorem mk_coe_symm (e : PartialEquiv X Y) (a b c d) :
    ((OpenPartialHomeomorph.mk e a b c d).symm : Y → X) = e.symm
```

-- snippet 6
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.toPartialEquiv_injective (L111-L116)
theorem toPartialEquiv_injective :
    Injective (toPartialEquiv : OpenPartialHomeomorph X Y → PartialEquiv X Y)
  | ⟨_, _, _, _, _⟩, ⟨_, _, _, _, _⟩, rfl => rfl

/- Register a few simp lemmas to make sure that `simp` puts the application of a local
homeomorphism in its normal form, i.e., in terms of its coercion to a function. -/
```

-- snippet 7
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.toFun_eq_coe (L118-L120)
theorem toFun_eq_coe (e : OpenPartialHomeomorph X Y) : e.toFun = e
```

-- snippet 8
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Defs.invFun_eq_coe (L122-L124)
theorem invFun_eq_coe (e : OpenPartialHomeomorph X Y) : e.invFun = e.symm
```

-- snippet 9
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_source_inter_eq' (L54-L56)
theorem image_source_inter_eq' (s : Set X) : e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' s
```

-- snippet 10
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_source_inter_eq (L57-L60)
theorem image_source_inter_eq (s : Set X) :
    e '' (e.source ∩ s) = e.target ∩ e.symm ⁻¹' (e.source ∩ s)
```

-- snippet 11
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.refl_partialEquiv (L38-L40)
theorem refl_partialEquiv : (OpenPartialHomeomorph.refl X).toPartialEquiv = PartialEquiv.refl X
```

-- snippet 12
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.image_eq_target_inter_inv_preimage (L50-L53)
theorem image_eq_target_inter_inv_preimage {s : Set X} (h : s ⊆ e.source) :
    e '' s = e.target ∩ e.symm ⁻¹' s
```

-- snippet 13
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.refl_symm (L42-L46)
theorem refl_symm : (OpenPartialHomeomorph.refl X).symm = OpenPartialHomeomorph.refl X
```

-- snippet 14
```lean
-- Mathlib.Topology.OpenPartialHomeomorph.Basic.source_preimage_target (L47-L49)
theorem source_preimage_target : e.source ⊆ e ⁻¹' e.target
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.GroupTheory.Perm.Cycle.Basic).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
    IsConj σ τ ↔ #σ.support = #τ.support where
  mp h
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L53-L55)
def SameCycle (f : Perm α) (x y : α) : Prop
```

-- snippet 2
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L57-L59)
theorem SameCycle.refl (f : Perm α) (x : α) : SameCycle f x x
```

-- snippet 3
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L60-L64)
theorem SameCycle.rfl : SameCycle f x x
```

-- snippet 4
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L66-L68)
theorem SameCycle.symm : SameCycle f x y → SameCycle f y x
```

-- snippet 5
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.sameCycle_comm (L69-L71)
theorem sameCycle_comm : SameCycle f x y ↔ SameCycle f y x
```

-- snippet 6
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L73-L76)
theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x z
```

-- snippet 7
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L77-L80)
theorem SameCycle.equivalence : Equivalence (SameCycle f)
```

-- snippet 8
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L82-L85)
def SameCycle.setoid (f : Perm α) : Setoid α where
  r
```

-- snippet 9
```lean
-- Mathlib.GroupTheory.Perm.Basic.SurjOn (L59-L60)
lemma SurjOn.perm_pow : SurjOn f s s → ∀ n : ℕ, SurjOn (f ^ n) s s
```

-- snippet 10
```lean
-- Mathlib.GroupTheory.Perm.Basic.MapsTo (L57-L58)
lemma MapsTo.perm_pow : MapsTo f s s → ∀ n : ℕ, MapsTo (f ^ n) s s
```

-- snippet 11
```lean
-- Mathlib.GroupTheory.Perm.Basic.swap_smul_involutive (L44-L54)
theorem swap_smul_involutive [MulAction (Perm α) β] (i j : α) :
    Function.Involutive (swap i j • · : β → β)
```

-- snippet 12
```lean
-- Mathlib.GroupTheory.Perm.Basic.swap_smul_self_smul (L41-L43)
theorem swap_smul_self_smul [MulAction (Perm α) β] (i j : α) (x : β) :
    swap i j • swap i j • x = x
```

-- snippet 13
```lean
-- Mathlib.GroupTheory.Perm.Centralizer.Subgroup (L116-L130)
lemma Subgroup.Centralizer.toConjAct_smul_mem_cycleFactorsFinset {k c : Perm α}
    (k_mem : k ∈ centralizer {g}) (c_mem : c ∈ g.cycleFactorsFinset) :
    ConjAct.toConjAct k • c ∈ g.cycleFactorsFinset
```

-- snippet 14
```lean
-- Mathlib.GroupTheory.Perm.Basic.BijOn (L55-L56)
lemma BijOn.perm_inv (hf : BijOn f s s) : BijOn ↑(f⁻¹) s s
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.GroupTheory.Perm.Cycle.Basic).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
    IsConj σ τ ↔ #σ.support = #τ.support where
  mp h
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L53-L55)
def SameCycle (f : Perm α) (x y : α) : Prop
```

-- snippet 2
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L57-L59)
theorem SameCycle.refl (f : Perm α) (x : α) : SameCycle f x x
```

-- snippet 3
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L60-L64)
theorem SameCycle.rfl : SameCycle f x x
```

-- snippet 4
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L66-L68)
theorem SameCycle.symm : SameCycle f x y → SameCycle f y x
```

-- snippet 5
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.sameCycle_comm (L69-L71)
theorem sameCycle_comm : SameCycle f x y ↔ SameCycle f y x
```

-- snippet 6
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L73-L76)
theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x z
```

-- snippet 7
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L77-L80)
theorem SameCycle.equivalence : Equivalence (SameCycle f)
```

-- snippet 8
```lean
-- Mathlib.GroupTheory.Perm.Cycle.Basic.SameCycle (L82-L85)
def SameCycle.setoid (f : Perm α) : Setoid α where
  r
```

-- snippet 9
```lean
-- Mathlib.GroupTheory.Perm.Basic.SurjOn (L59-L60)
lemma SurjOn.perm_pow : SurjOn f s s → ∀ n : ℕ, SurjOn (f ^ n) s s
```

-- snippet 10
```lean
-- Mathlib.GroupTheory.Perm.Basic.MapsTo (L57-L58)
lemma MapsTo.perm_pow : MapsTo f s s → ∀ n : ℕ, MapsTo (f ^ n) s s
```

-- snippet 11
```lean
-- Mathlib.GroupTheory.Perm.Basic.swap_smul_involutive (L44-L54)
theorem swap_smul_involutive [MulAction (Perm α) β] (i j : α) :
    Function.Involutive (swap i j • · : β → β)
```

-- snippet 12
```lean
-- Mathlib.GroupTheory.Perm.Basic.swap_smul_self_smul (L41-L43)
theorem swap_smul_self_smul [MulAction (Perm α) β] (i j : α) (x : β) :
    swap i j • swap i j • x = x
```

-- snippet 13
```lean
-- Mathlib.GroupTheory.Perm.Centralizer.Subgroup (L116-L130)
lemma Subgroup.Centralizer.toConjAct_smul_mem_cycleFactorsFinset {k c : Perm α}
    (k_mem : k ∈ centralizer {g}) (c_mem : c ∈ g.cycleFactorsFinset) :
    ConjAct.toConjAct k • c ∈ g.cycleFactorsFinset
```

-- snippet 14
```lean
-- Mathlib.GroupTheory.Perm.Basic.BijOn (L55-L56)
lemma BijOn.perm_inv (hf : BijOn f s s) : BijOn ↑(f⁻¹) s s
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Analytic.ChangeOrigin).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
def changeOriginSeries (k : ℕ) : FormalMultilinearSeries 𝕜 E (E [×k]→L[𝕜] F)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOriginSeriesTerm (L64-L69)
def changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    E [×l]→L[𝕜] E [×k]→L[𝕜] F
```

-- snippet 2
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOriginSeriesTerm_apply (L70-L75)
theorem changeOriginSeriesTerm_apply (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l)
    (x y : E) :
    (p.changeOriginSeriesTerm k l s hs (fun _ => x) fun _ => y) =
      p (k + l) (s.piecewise (fun _ => x) fun _ => y)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.norm_changeOriginSeriesTerm (L77-L80)
theorem norm_changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    ‖p.changeOriginSeriesTerm k l s hs‖ = ‖p (k + l)‖
```

-- snippet 4
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeriesTerm (L82-L85)
theorem nnnorm_changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    ‖p.changeOriginSeriesTerm k l s hs‖₊ = ‖p (k + l)‖₊
```

-- snippet 5
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeriesTerm_apply_le (L86-L99)
theorem nnnorm_changeOriginSeriesTerm_apply_le (k l : ℕ) (s : Finset (Fin (k + l)))
    (hs : s.card = l) (x y : E) :
    ‖p.changeOriginSeriesTerm k l s hs (fun _ => x) fun _ => y‖₊ ≤
      ‖p (k + l)‖₊ * ‖x‖₊ ^ l * ‖y‖₊ ^ k
```

-- snippet 6
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeries_le_tsum (L103-L108)
theorem nnnorm_changeOriginSeries_le_tsum (k l : ℕ) :
    ‖p.changeOriginSeries k l‖₊ ≤
      ∑' _ : { s : Finset (Fin (k + l)) // s.card = l }, ‖p (k + l)‖₊
```

-- snippet 7
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeries_apply_le_tsum (L109-L117)
theorem nnnorm_changeOriginSeries_apply_le_tsum (k l : ℕ) (x : E) :
    ‖p.changeOriginSeries k l fun _ => x‖₊ ≤
      ∑' _ : { s : Finset (Fin (k + l)) // s.card = l }, ‖p (k + l)‖₊ * ‖x‖₊ ^ l
```

-- snippet 8
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOrigin (L118-L128)
def changeOrigin (x : E) : FormalMultilinearSeries 𝕜 E F
```

-- snippet 9
```lean
-- Mathlib.Analysis.Analytic.Basic.HasFPowerSeriesWithinAt (L98-L101)
def HasFPowerSeriesWithinAt (f : E → F) (p : FormalMultilinearSeries 𝕜 E F) (s : Set E) (x : E)
```

-- snippet 10
```lean
-- Mathlib.Analysis.Analytic.Basic.HasFPowerSeriesAt (L94-L97)
def HasFPowerSeriesAt (f : E → F) (p : FormalMultilinearSeries 𝕜 E F) (x : E)
```

-- snippet 11
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticWithinAt (L113-L117)
def AnalyticWithinAt (f : E → F) (s : Set E) (x : E) : Prop
```

-- snippet 12
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticOnNhd (L118-L122)
def AnalyticOnNhd (f : E → F) (s : Set E)
```

-- snippet 13
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticAt (L109-L112)
def AnalyticAt (f : E → F) (x : E)
```

-- snippet 14
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticOn (L123-L131)
def AnalyticOn (f : E → F) (s : Set E) : Prop
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Analytic.ChangeOrigin).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
def changeOriginSeries (k : ℕ) : FormalMultilinearSeries 𝕜 E (E [×k]→L[𝕜] F)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOriginSeriesTerm (L64-L69)
def changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    E [×l]→L[𝕜] E [×k]→L[𝕜] F
```

-- snippet 2
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOriginSeriesTerm_apply (L70-L75)
theorem changeOriginSeriesTerm_apply (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l)
    (x y : E) :
    (p.changeOriginSeriesTerm k l s hs (fun _ => x) fun _ => y) =
      p (k + l) (s.piecewise (fun _ => x) fun _ => y)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.norm_changeOriginSeriesTerm (L77-L80)
theorem norm_changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    ‖p.changeOriginSeriesTerm k l s hs‖ = ‖p (k + l)‖
```

-- snippet 4
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeriesTerm (L82-L85)
theorem nnnorm_changeOriginSeriesTerm (k l : ℕ) (s : Finset (Fin (k + l))) (hs : s.card = l) :
    ‖p.changeOriginSeriesTerm k l s hs‖₊ = ‖p (k + l)‖₊
```

-- snippet 5
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeriesTerm_apply_le (L86-L99)
theorem nnnorm_changeOriginSeriesTerm_apply_le (k l : ℕ) (s : Finset (Fin (k + l)))
    (hs : s.card = l) (x y : E) :
    ‖p.changeOriginSeriesTerm k l s hs (fun _ => x) fun _ => y‖₊ ≤
      ‖p (k + l)‖₊ * ‖x‖₊ ^ l * ‖y‖₊ ^ k
```

-- snippet 6
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeries_le_tsum (L103-L108)
theorem nnnorm_changeOriginSeries_le_tsum (k l : ℕ) :
    ‖p.changeOriginSeries k l‖₊ ≤
      ∑' _ : { s : Finset (Fin (k + l)) // s.card = l }, ‖p (k + l)‖₊
```

-- snippet 7
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.nnnorm_changeOriginSeries_apply_le_tsum (L109-L117)
theorem nnnorm_changeOriginSeries_apply_le_tsum (k l : ℕ) (x : E) :
    ‖p.changeOriginSeries k l fun _ => x‖₊ ≤
      ∑' _ : { s : Finset (Fin (k + l)) // s.card = l }, ‖p (k + l)‖₊ * ‖x‖₊ ^ l
```

-- snippet 8
```lean
-- Mathlib.Analysis.Analytic.ChangeOrigin.changeOrigin (L118-L128)
def changeOrigin (x : E) : FormalMultilinearSeries 𝕜 E F
```

-- snippet 9
```lean
-- Mathlib.Analysis.Analytic.Basic.HasFPowerSeriesWithinAt (L98-L101)
def HasFPowerSeriesWithinAt (f : E → F) (p : FormalMultilinearSeries 𝕜 E F) (s : Set E) (x : E)
```

-- snippet 10
```lean
-- Mathlib.Analysis.Analytic.Basic.HasFPowerSeriesAt (L94-L97)
def HasFPowerSeriesAt (f : E → F) (p : FormalMultilinearSeries 𝕜 E F) (x : E)
```

-- snippet 11
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticWithinAt (L113-L117)
def AnalyticWithinAt (f : E → F) (s : Set E) (x : E) : Prop
```

-- snippet 12
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticOnNhd (L118-L122)
def AnalyticOnNhd (f : E → F) (s : Set E)
```

-- snippet 13
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticAt (L109-L112)
def AnalyticAt (f : E → F) (x : E)
```

-- snippet 14
```lean
-- Mathlib.Analysis.Analytic.Basic.AnalyticOn (L123-L131)
def AnalyticOn (f : E → F) (s : Set E) : Prop
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.NumberTheory.Modular).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem lcRow0_apply (p : Fin 2 → ℤ) (g : Matrix (Fin 2) (Fin 2) ℝ) :
    lcRow0 p g = p 0 * g 0 0 + p 1 * g 0 1
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.NumberTheory.Modular.bottom_row_coprime (L86-L91)
theorem bottom_row_coprime {R : Type*} [CommRing R] (g : SL(2, R)) :
    IsCoprime ((↑g : Matrix (Fin 2) (Fin 2) R) 1 0) ((↑g : Matrix (Fin 2) (Fin 2) R) 1 1)
```

-- snippet 2
```lean
-- Mathlib.NumberTheory.Modular.bottom_row_surj (L92-L109)
theorem bottom_row_surj {R : Type*} [CommRing R] :
    Set.SurjOn (fun g : SL(2, R) => (↑g : Matrix (Fin 2) (Fin 2) R) 1) Set.univ
      {cd | IsCoprime (cd 0) (cd 1)}
```

-- snippet 3
```lean
-- Mathlib.NumberTheory.Modular.tendsto_normSq_coprime_pair (L115-L163)
theorem tendsto_normSq_coprime_pair :
    Filter.Tendsto (fun p : Fin 2 → ℤ => normSq ((p 0 : ℂ) * z + p 1)) cofinite atTop
```

-- snippet 4
```lean
-- Mathlib.NumberTheory.Modular.lcRow0 (L164-L168)
def lcRow0 (p : Fin 2 → ℤ) : Matrix (Fin 2) (Fin 2) ℝ →ₗ[ℝ] ℝ
```

-- snippet 5
```lean
-- Mathlib.NumberTheory.Modular.lcRow0Extend (L177-L189)
def lcRow0Extend {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Matrix (Fin 2) (Fin 2) ℝ ≃ₗ[ℝ] Matrix (Fin 2) (Fin 2) ℝ
```

-- snippet 6
```lean
-- Mathlib.NumberTheory.Modular.tendsto_lcRow0 (L190-L233)
theorem tendsto_lcRow0 {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Tendsto (fun g : { g : SL(2, ℤ) // g 1 = cd } => lcRow0 cd ↑(↑g : SL(2, ℝ))) cofinite
      (cocompact ℝ)
```

-- snippet 7
```lean
-- Mathlib.NumberTheory.Modular.smul_eq_lcRow0_add (L234-L249)
theorem smul_eq_lcRow0_add {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) (hg : g 1 = p) :
    ↑(g • z) =
      (lcRow0 p ↑(g : SL(2, ℝ)) : ℂ) / ((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) +
        ((p 1 : ℂ) * z - p 0) / (((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) * (p 0 * z + p 1))
```

-- snippet 8
```lean
-- Mathlib.NumberTheory.Modular.tendsto_abs_re_smul (L250-L274)
theorem tendsto_abs_re_smul {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) :
    Tendsto
      (fun g : { g : SL(2, ℤ) // g 1 = p } => |((g : SL(2, ℤ)) • z).re|) cofinite atTop
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.NumberTheory.Modular).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem lcRow0_apply (p : Fin 2 → ℤ) (g : Matrix (Fin 2) (Fin 2) ℝ) :
    lcRow0 p g = p 0 * g 0 0 + p 1 * g 0 1
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.NumberTheory.Modular.bottom_row_coprime (L86-L91)
theorem bottom_row_coprime {R : Type*} [CommRing R] (g : SL(2, R)) :
    IsCoprime ((↑g : Matrix (Fin 2) (Fin 2) R) 1 0) ((↑g : Matrix (Fin 2) (Fin 2) R) 1 1)
```

-- snippet 2
```lean
-- Mathlib.NumberTheory.Modular.bottom_row_surj (L92-L109)
theorem bottom_row_surj {R : Type*} [CommRing R] :
    Set.SurjOn (fun g : SL(2, R) => (↑g : Matrix (Fin 2) (Fin 2) R) 1) Set.univ
      {cd | IsCoprime (cd 0) (cd 1)}
```

-- snippet 3
```lean
-- Mathlib.NumberTheory.Modular.tendsto_normSq_coprime_pair (L115-L163)
theorem tendsto_normSq_coprime_pair :
    Filter.Tendsto (fun p : Fin 2 → ℤ => normSq ((p 0 : ℂ) * z + p 1)) cofinite atTop
```

-- snippet 4
```lean
-- Mathlib.NumberTheory.Modular.lcRow0 (L164-L168)
def lcRow0 (p : Fin 2 → ℤ) : Matrix (Fin 2) (Fin 2) ℝ →ₗ[ℝ] ℝ
```

-- snippet 5
```lean
-- Mathlib.NumberTheory.Modular.lcRow0Extend (L177-L189)
def lcRow0Extend {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Matrix (Fin 2) (Fin 2) ℝ ≃ₗ[ℝ] Matrix (Fin 2) (Fin 2) ℝ
```

-- snippet 6
```lean
-- Mathlib.NumberTheory.Modular.tendsto_lcRow0 (L190-L233)
theorem tendsto_lcRow0 {cd : Fin 2 → ℤ} (hcd : IsCoprime (cd 0) (cd 1)) :
    Tendsto (fun g : { g : SL(2, ℤ) // g 1 = cd } => lcRow0 cd ↑(↑g : SL(2, ℝ))) cofinite
      (cocompact ℝ)
```

-- snippet 7
```lean
-- Mathlib.NumberTheory.Modular.smul_eq_lcRow0_add (L234-L249)
theorem smul_eq_lcRow0_add {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) (hg : g 1 = p) :
    ↑(g • z) =
      (lcRow0 p ↑(g : SL(2, ℝ)) : ℂ) / ((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) +
        ((p 1 : ℂ) * z - p 0) / (((p 0 : ℂ) ^ 2 + (p 1 : ℂ) ^ 2) * (p 0 * z + p 1))
```

-- snippet 8
```lean
-- Mathlib.NumberTheory.Modular.tendsto_abs_re_smul (L250-L274)
theorem tendsto_abs_re_smul {p : Fin 2 → ℤ} (hp : IsCoprime (p 0) (p 1)) :
    Tendsto
      (fun g : { g : SL(2, ℤ) // g 1 = p } => |((g : SL(2, ℤ)) • z).re|) cofinite atTop
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
lemma derivWeierstrassP_zero : ℘'[L] 0 = 0
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.lattice (L79-L80)
def lattice : Submodule ℤ ℂ
```

-- snippet 2
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.mem_lattice (L81-L84)
lemma mem_lattice {L : PeriodPair} {x : ℂ} :
    x ∈ L.lattice ↔ ∃ m n : ℤ, m * L.ω₁ + n * L.ω₂ = x
```

-- snippet 3
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₁_mem_lattice (L85-L85)
lemma ω₁_mem_lattice : L.ω₁ ∈ L.lattice
```

-- snippet 4
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₂_mem_lattice (L86-L88)
lemma ω₂_mem_lattice : L.ω₂ ∈ L.lattice
```

-- snippet 5
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.mul_ω₁_add_mul_ω₂_mem_lattice (L89-L103)
lemma mul_ω₁_add_mul_ω₂_mem_lattice {L : PeriodPair} {α β : ℚ} :
    α * L.ω₁ + β * L.ω₂ ∈ L.lattice ↔ α.den = 1 ∧ β.den = 1
```

-- snippet 6
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₁_div_two_notMem_lattice (L104-L107)
lemma ω₁_div_two_notMem_lattice : L.ω₁ / 2 ∉ L.lattice
```

-- snippet 7
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₂_div_two_notMem_lattice (L108-L112)
lemma ω₂_div_two_notMem_lattice : L.ω₂ / 2 ∉ L.lattice
```

-- snippet 8
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.lattice_eq_span_range_basis (L113-L118)
lemma lattice_eq_span_range_basis :
    L.lattice = Submodule.span ℤ (Set.range L.basis)
```

-- snippet 9
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh_eq_zero_iff (L81-L84)
theorem arcosh_eq_zero_iff {x : ℝ} (hx : 1 ≤ x) : arcosh x = 0 ↔ x = 1
```

-- snippet 10
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh_zero (L69-L70)
theorem arcosh_zero : arcosh 1 = 0
```

-- snippet 11
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.cosh_arcosh (L77-L80)
theorem cosh_arcosh {x : ℝ} (hx : 1 ≤ x) : cosh (arcosh x) = x
```

-- snippet 12
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.add_sqrt_self_sq_sub_one_inv (L71-L76)
lemma add_sqrt_self_sq_sub_one_inv {x : ℝ} (hx : 1 ≤ x) :
    (x + √(x ^ 2 - 1))⁻¹ = x - √(x ^ 2 - 1)
```

-- snippet 13
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.exp_arcosh (L64-L67)
theorem exp_arcosh {x : ℝ} (hx : 1 ≤ x) : exp (arcosh x) = x + √(x ^ 2 - 1)
```

-- snippet 14
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh (L61-L63)
def arcosh (x : ℝ)
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
lemma derivWeierstrassP_zero : ℘'[L] 0 = 0
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.lattice (L79-L80)
def lattice : Submodule ℤ ℂ
```

-- snippet 2
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.mem_lattice (L81-L84)
lemma mem_lattice {L : PeriodPair} {x : ℂ} :
    x ∈ L.lattice ↔ ∃ m n : ℤ, m * L.ω₁ + n * L.ω₂ = x
```

-- snippet 3
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₁_mem_lattice (L85-L85)
lemma ω₁_mem_lattice : L.ω₁ ∈ L.lattice
```

-- snippet 4
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₂_mem_lattice (L86-L88)
lemma ω₂_mem_lattice : L.ω₂ ∈ L.lattice
```

-- snippet 5
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.mul_ω₁_add_mul_ω₂_mem_lattice (L89-L103)
lemma mul_ω₁_add_mul_ω₂_mem_lattice {L : PeriodPair} {α β : ℚ} :
    α * L.ω₁ + β * L.ω₂ ∈ L.lattice ↔ α.den = 1 ∧ β.den = 1
```

-- snippet 6
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₁_div_two_notMem_lattice (L104-L107)
lemma ω₁_div_two_notMem_lattice : L.ω₁ / 2 ∉ L.lattice
```

-- snippet 7
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.ω₂_div_two_notMem_lattice (L108-L112)
lemma ω₂_div_two_notMem_lattice : L.ω₂ / 2 ∉ L.lattice
```

-- snippet 8
```lean
-- Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.lattice_eq_span_range_basis (L113-L118)
lemma lattice_eq_span_range_basis :
    L.lattice = Submodule.span ℤ (Set.range L.basis)
```

-- snippet 9
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh_eq_zero_iff (L81-L84)
theorem arcosh_eq_zero_iff {x : ℝ} (hx : 1 ≤ x) : arcosh x = 0 ↔ x = 1
```

-- snippet 10
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh_zero (L69-L70)
theorem arcosh_zero : arcosh 1 = 0
```

-- snippet 11
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.cosh_arcosh (L77-L80)
theorem cosh_arcosh {x : ℝ} (hx : 1 ≤ x) : cosh (arcosh x) = x
```

-- snippet 12
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.add_sqrt_self_sq_sub_one_inv (L71-L76)
lemma add_sqrt_self_sq_sub_one_inv {x : ℝ} (hx : 1 ≤ x) :
    (x + √(x ^ 2 - 1))⁻¹ = x - √(x ^ 2 - 1)
```

-- snippet 13
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.exp_arcosh (L64-L67)
theorem exp_arcosh {x : ℝ} (hx : 1 ≤ x) : exp (arcosh x) = x + √(x ^ 2 - 1)
```

-- snippet 14
```lean
-- Mathlib.Analysis.SpecialFunctions.Arcosh.arcosh (L61-L63)
def arcosh (x : ℝ)
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Complex.Schwarz).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem norm_le_norm_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball 0 R))
    (h_maps : MapsTo f (ball 0 R) (closedBall 0 R)) (h₀ : f 0 = 0) (hz : ‖z‖ < R) :
    ‖f z‖ ≤ ‖z‖
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Complex.Schwarz.schwarz_aux (L64-L143)
theorem schwarz_aux {f : ℂ → ℂ} {c z : ℂ} {R₁ R₂ : ℝ} {n : ℕ}
    (hd : DifferentiableOn ℂ f (ball c R₁)) (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂))
    (hn : (f · - f c) =o[𝓝 c] (fun w ↦ (w - c) ^ n)) (hz : z ∈ ball c R₁) :
    ‖f z - f c‖ ≤ R₂ * (‖z - c‖ / R₁) ^ (n + 1)
```

-- snippet 2
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_mul_div_pow_of_mapsTo_ball_of_isLittleO (L144-L187)
theorem dist_le_mul_div_pow_of_mapsTo_ball_of_isLittleO {f : E → F} {c z : E} {R₁ R₂ : ℝ} {n : ℕ}
    (hd : DifferentiableOn ℂ f (ball c R₁)) (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂))
    (hn : (f · - f c) =o[𝓝 c] (fun w ↦ ‖w - c‖ ^ n)) (hz : z ∈ ball c R₁) :
    dist (f z) (f c) ≤ R₂ * (dist z c / R₁) ^ (n + 1)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_div_mul_dist_of_mapsTo_ball (L188-L200)
theorem dist_le_div_mul_dist_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (hz : z ∈ ball c R₁) :
    dist (f z) (f c) ≤ R₂ / R₁ * dist z c
```

-- snippet 4
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_fderiv_le_div_of_mapsTo_ball (L201-L213)
theorem norm_fderiv_le_div_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (h₀ : 0 < R₁) :
    ‖fderiv ℂ f c‖ ≤ R₂ / R₁
```

-- snippet 5
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_dist_of_mapsTo_ball (L214-L218)
theorem dist_le_dist_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (hz : z ∈ ball c R) :
    dist (f z) (f c) ≤ dist z c
```

-- snippet 6
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_fderiv_le_one_of_mapsTo_ball (L227-L235)
theorem norm_fderiv_le_one_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (hR : 0 < R) :
    ‖fderiv ℂ f c‖ ≤ 1
```

-- snippet 7
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_deriv_le_div_of_mapsTo_ball (L255-L265)
theorem norm_deriv_le_div_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (h₀ : 0 < R₁) :
    ‖deriv f c‖ ≤ R₂ / R₁
```

-- snippet 8
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_deriv_le_one_of_mapsTo_ball (L266-L276)
theorem norm_deriv_le_one_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (h₀ : 0 < R) : ‖deriv f c‖ ≤ 1
```

-- snippet 9
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzSet (L48-L50)
def stolzSet (M : ℝ) : Set ℂ
```

-- snippet 10
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzCone_subset_stolzSet_aux (L99-L112)
lemma stolzCone_subset_stolzSet_aux {s : ℝ} (hs : 0 < s) :
    ∃ M ε, 0 < M ∧ 0 < ε ∧ {z : ℂ | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
```

-- snippet 11
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzCone (L51-L52)
def stolzCone (s : ℝ) : Set ℂ
```

-- snippet 12
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzSet_empty (L53-L61)
theorem stolzSet_empty {M : ℝ} (hM : M ≤ 1) : stolzSet M = ∅
```

-- snippet 13
```lean
-- Mathlib.Analysis.Complex.AbelLimit.nhdsWithin_stolzCone_le_nhdsWithin_stolzSet (L113-L127)
lemma nhdsWithin_stolzCone_le_nhdsWithin_stolzSet {s : ℝ} (hs : 0 < s) :
    ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
```

-- snippet 14
```lean
-- Mathlib.Analysis.Complex.AbelLimit.nhdsWithin_lt_le_nhdsWithin_stolzSet (L62-L98)
theorem nhdsWithin_lt_le_nhdsWithin_stolzSet {M : ℝ} (hM : 1 < M) :
    (𝓝[<] 1).map ofReal ≤ 𝓝[stolzSet M] 1
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.Complex.Schwarz).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem norm_le_norm_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball 0 R))
    (h_maps : MapsTo f (ball 0 R) (closedBall 0 R)) (h₀ : f 0 = 0) (hz : ‖z‖ < R) :
    ‖f z‖ ≤ ‖z‖
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.Complex.Schwarz.schwarz_aux (L64-L143)
theorem schwarz_aux {f : ℂ → ℂ} {c z : ℂ} {R₁ R₂ : ℝ} {n : ℕ}
    (hd : DifferentiableOn ℂ f (ball c R₁)) (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂))
    (hn : (f · - f c) =o[𝓝 c] (fun w ↦ (w - c) ^ n)) (hz : z ∈ ball c R₁) :
    ‖f z - f c‖ ≤ R₂ * (‖z - c‖ / R₁) ^ (n + 1)
```

-- snippet 2
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_mul_div_pow_of_mapsTo_ball_of_isLittleO (L144-L187)
theorem dist_le_mul_div_pow_of_mapsTo_ball_of_isLittleO {f : E → F} {c z : E} {R₁ R₂ : ℝ} {n : ℕ}
    (hd : DifferentiableOn ℂ f (ball c R₁)) (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂))
    (hn : (f · - f c) =o[𝓝 c] (fun w ↦ ‖w - c‖ ^ n)) (hz : z ∈ ball c R₁) :
    dist (f z) (f c) ≤ R₂ * (dist z c / R₁) ^ (n + 1)
```

-- snippet 3
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_div_mul_dist_of_mapsTo_ball (L188-L200)
theorem dist_le_div_mul_dist_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (hz : z ∈ ball c R₁) :
    dist (f z) (f c) ≤ R₂ / R₁ * dist z c
```

-- snippet 4
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_fderiv_le_div_of_mapsTo_ball (L201-L213)
theorem norm_fderiv_le_div_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (h₀ : 0 < R₁) :
    ‖fderiv ℂ f c‖ ≤ R₂ / R₁
```

-- snippet 5
```lean
-- Mathlib.Analysis.Complex.Schwarz.dist_le_dist_of_mapsTo_ball (L214-L218)
theorem dist_le_dist_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (hz : z ∈ ball c R) :
    dist (f z) (f c) ≤ dist z c
```

-- snippet 6
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_fderiv_le_one_of_mapsTo_ball (L227-L235)
theorem norm_fderiv_le_one_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (hR : 0 < R) :
    ‖fderiv ℂ f c‖ ≤ 1
```

-- snippet 7
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_deriv_le_div_of_mapsTo_ball (L255-L265)
theorem norm_deriv_le_div_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : MapsTo f (ball c R₁) (closedBall (f c) R₂)) (h₀ : 0 < R₁) :
    ‖deriv f c‖ ≤ R₂ / R₁
```

-- snippet 8
```lean
-- Mathlib.Analysis.Complex.Schwarz.norm_deriv_le_one_of_mapsTo_ball (L266-L276)
theorem norm_deriv_le_one_of_mapsTo_ball (hd : DifferentiableOn ℂ f (ball c R))
    (h_maps : MapsTo f (ball c R) (closedBall (f c) R)) (h₀ : 0 < R) : ‖deriv f c‖ ≤ 1
```

-- snippet 9
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzSet (L48-L50)
def stolzSet (M : ℝ) : Set ℂ
```

-- snippet 10
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzCone_subset_stolzSet_aux (L99-L112)
lemma stolzCone_subset_stolzSet_aux {s : ℝ} (hs : 0 < s) :
    ∃ M ε, 0 < M ∧ 0 < ε ∧ {z : ℂ | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
```

-- snippet 11
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzCone (L51-L52)
def stolzCone (s : ℝ) : Set ℂ
```

-- snippet 12
```lean
-- Mathlib.Analysis.Complex.AbelLimit.stolzSet_empty (L53-L61)
theorem stolzSet_empty {M : ℝ} (hM : M ≤ 1) : stolzSet M = ∅
```

-- snippet 13
```lean
-- Mathlib.Analysis.Complex.AbelLimit.nhdsWithin_stolzCone_le_nhdsWithin_stolzSet (L113-L127)
lemma nhdsWithin_stolzCone_le_nhdsWithin_stolzSet {s : ℝ} (hs : 0 < s) :
    ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
```

-- snippet 14
```lean
-- Mathlib.Analysis.Complex.AbelLimit.nhdsWithin_lt_le_nhdsWithin_stolzSet (L62-L98)
theorem nhdsWithin_lt_le_nhdsWithin_stolzSet {M : ℝ} (hM : 1 < M) :
    (𝓝[<] 1).map ofReal ≤ 𝓝[stolzSet M] 1
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Group.Shrink).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
lemma equivShrink_mul [Mul α] (x y : α) :
    equivShrink α (x * y) = equivShrink α x * equivShrink α y
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_one (L31-L33)
lemma equivShrink_symm_one [One α] : (equivShrink α).symm 1 = 1
```

-- snippet 2
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_mul (L35-L38)
lemma equivShrink_symm_mul [Mul α] (x y : Shrink α) :
    (equivShrink α).symm (x * y) = (equivShrink α).symm x * (equivShrink α).symm y
```

-- snippet 3
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_smul (L45-L48)
lemma equivShrink_symm_smul {M : Type*} [SMul M α] (m : M) (x : Shrink α) :
    (equivShrink α).symm (m • x) = m • (equivShrink α).symm x
```

-- snippet 4
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_smul (L50-L52)
lemma equivShrink_smul {M : Type*} [SMul M α] (m : M) (x : α) :
    equivShrink α (m • x) = m • equivShrink α x
```

-- snippet 5
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_div (L54-L57)
lemma equivShrink_symm_div [Div α] (x y : Shrink α) :
    (equivShrink α).symm (x / y) = (equivShrink α).symm x / (equivShrink α).symm y
```

-- snippet 6
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_div (L59-L62)
lemma equivShrink_div [Div α] (x y : α) :
    equivShrink α (x / y) = equivShrink α x / equivShrink α y
```

-- snippet 7
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_inv (L64-L67)
lemma equivShrink_symm_inv [Inv α] (x : Shrink α) :
    (equivShrink α).symm x⁻¹ = ((equivShrink α).symm x)⁻¹
```

-- snippet 8
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_inv (L69-L74)
lemma equivShrink_inv [Inv α] (x : α) : equivShrink α x⁻¹ = (equivShrink α x)⁻¹
```

-- snippet 9
```lean
-- Mathlib.Algebra.Group.Action.Basic.invOf_smul_eq_iff (L86-L87)
lemma invOf_smul_eq_iff : ⅟c • x = y ↔ x = c • y
```

-- snippet 10
```lean
-- Mathlib.Algebra.Group.Action.Basic.isCancelSMul_iff_eq_one_of_smul_eq (L70-L80)
lemma isCancelSMul_iff_eq_one_of_smul_eq :
    IsCancelSMul α β ↔ (∀ (g : α) (x : β), g • x = x → g = 1)
```

-- snippet 11
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_left_cancel (L59-L60)
lemma smul_left_cancel (g : α) {x y : β} (h : g • x = g • y) : x = y
```

-- snippet 12
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_eq_iff_eq_inv_smul (L66-L68)
lemma smul_eq_iff_eq_inv_smul (g : α) {x y : β} : g • x = y ↔ x = g⁻¹ • y
```

-- snippet 13
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_left_cancel_iff (L62-L64)
lemma smul_left_cancel_iff (g : α) {x y : β} : g • x = g • y ↔ x = y
```

-- snippet 14
```lean
-- Mathlib.Algebra.Group.Action.Basic.MulAction (L34-L40)
def MulAction.toPerm (a : α) : Equiv.Perm β
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Algebra.Group.Shrink).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
lemma equivShrink_mul [Mul α] (x y : α) :
    equivShrink α (x * y) = equivShrink α x * equivShrink α y
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_one (L31-L33)
lemma equivShrink_symm_one [One α] : (equivShrink α).symm 1 = 1
```

-- snippet 2
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_mul (L35-L38)
lemma equivShrink_symm_mul [Mul α] (x y : Shrink α) :
    (equivShrink α).symm (x * y) = (equivShrink α).symm x * (equivShrink α).symm y
```

-- snippet 3
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_smul (L45-L48)
lemma equivShrink_symm_smul {M : Type*} [SMul M α] (m : M) (x : Shrink α) :
    (equivShrink α).symm (m • x) = m • (equivShrink α).symm x
```

-- snippet 4
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_smul (L50-L52)
lemma equivShrink_smul {M : Type*} [SMul M α] (m : M) (x : α) :
    equivShrink α (m • x) = m • equivShrink α x
```

-- snippet 5
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_div (L54-L57)
lemma equivShrink_symm_div [Div α] (x y : Shrink α) :
    (equivShrink α).symm (x / y) = (equivShrink α).symm x / (equivShrink α).symm y
```

-- snippet 6
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_div (L59-L62)
lemma equivShrink_div [Div α] (x y : α) :
    equivShrink α (x / y) = equivShrink α x / equivShrink α y
```

-- snippet 7
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_symm_inv (L64-L67)
lemma equivShrink_symm_inv [Inv α] (x : Shrink α) :
    (equivShrink α).symm x⁻¹ = ((equivShrink α).symm x)⁻¹
```

-- snippet 8
```lean
-- Mathlib.Algebra.Group.Shrink.equivShrink_inv (L69-L74)
lemma equivShrink_inv [Inv α] (x : α) : equivShrink α x⁻¹ = (equivShrink α x)⁻¹
```

-- snippet 9
```lean
-- Mathlib.Algebra.Group.Action.Basic.invOf_smul_eq_iff (L86-L87)
lemma invOf_smul_eq_iff : ⅟c • x = y ↔ x = c • y
```

-- snippet 10
```lean
-- Mathlib.Algebra.Group.Action.Basic.isCancelSMul_iff_eq_one_of_smul_eq (L70-L80)
lemma isCancelSMul_iff_eq_one_of_smul_eq :
    IsCancelSMul α β ↔ (∀ (g : α) (x : β), g • x = x → g = 1)
```

-- snippet 11
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_left_cancel (L59-L60)
lemma smul_left_cancel (g : α) {x y : β} (h : g • x = g • y) : x = y
```

-- snippet 12
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_eq_iff_eq_inv_smul (L66-L68)
lemma smul_eq_iff_eq_inv_smul (g : α) {x y : β} : g • x = y ↔ x = g⁻¹ • y
```

-- snippet 13
```lean
-- Mathlib.Algebra.Group.Action.Basic.smul_left_cancel_iff (L62-L64)
lemma smul_left_cancel_iff (g : α) {x y : β} : g • x = g • y ↔ x = y
```

-- snippet 14
```lean
-- Mathlib.Algebra.Group.Action.Basic.MulAction (L34-L40)
def MulAction.toPerm (a : α) : Equiv.Perm β
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.Algebra.Module.Alternating.Basic).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem alternatization_apply_apply (v : ι → M) :
    alternatization f v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ σ)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.toContinuousMultilinearMap_injective (L62-L66)
theorem toContinuousMultilinearMap_injective :
    Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
      M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)
  | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
```

-- snippet 2
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.range_toContinuousMultilinearMap (L67-L73)
theorem range_toContinuousMultilinearMap :
    Set.range
        (toContinuousMultilinearMap :
          M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N) =
      {f | ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → f v = 0}
```

-- snippet 3
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.funLike (L74-L77)
instance funLike : FunLike (M [⋀^ι]→L[R] N) (ι → M) N where
  coe f
```

-- snippet 4
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.continuousMapClass (L78-L82)
instance continuousMapClass : ContinuousMapClass (M [⋀^ι]→L[R] N) (ι → M) N where
  map_continuous f
```

-- snippet 5
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_continuous (L84-L85)
theorem coe_continuous : Continuous f
```

-- snippet 6
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_toContinuousMultilinearMap (L87-L89)
theorem coe_toContinuousMultilinearMap : ⇑f.toContinuousMultilinearMap = f
```

-- snippet 7
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_mk (L91-L95)
theorem coe_mk (f : ContinuousMultilinearMap R (fun _ : ι => M) N) (h) : ⇑(mk f h) = f
```

-- snippet 8
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_toAlternatingMap (L96-L97)
theorem coe_toAlternatingMap : ⇑f.toAlternatingMap = f
```

-- snippet 9
```lean
-- Mathlib.Topology.Algebra.Affine.isOpenMap_linear_iff (L46-L58)
theorem isOpenMap_linear_iff {f : P →ᵃ[R] Q} : IsOpenMap f.linear ↔ IsOpenMap f
```

-- snippet 10
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous_uncurry (L60-L65)
theorem lineMap_continuous_uncurry :
    Continuous (fun pqt : P × P × R ↦ lineMap pqt.1 pqt.2.1 pqt.2.2)
```

-- snippet 11
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous (L66-L75)
theorem lineMap_continuous {p q : P} :
    Continuous (lineMap p q : R →ᵃ[R] P)
```

-- snippet 12
```lean
-- Mathlib.Topology.Algebra.Affine.continuous_linear_iff (L35-L45)
theorem continuous_linear_iff {f : P →ᵃ[R] Q} : Continuous f.linear ↔ Continuous f
```

-- snippet 13
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_isOpenMap (L146-L152)
theorem homothety_isOpenMap (x : P) (t : R) (ht : t ≠ 0) : IsOpenMap <| homothety x t
```

-- snippet 14
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_continuous (L118-L125)
theorem homothety_continuous (x : P) (t : R) : Continuous <| homothety x t
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Topology.Algebra.Module.Alternating.Basic).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem alternatization_apply_apply (v : ι → M) :
    alternatization f v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ σ)
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.toContinuousMultilinearMap_injective (L62-L66)
theorem toContinuousMultilinearMap_injective :
    Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
      M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)
  | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
```

-- snippet 2
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.range_toContinuousMultilinearMap (L67-L73)
theorem range_toContinuousMultilinearMap :
    Set.range
        (toContinuousMultilinearMap :
          M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N) =
      {f | ∀ (v : ι → M) (i j : ι), v i = v j → i ≠ j → f v = 0}
```

-- snippet 3
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.funLike (L74-L77)
instance funLike : FunLike (M [⋀^ι]→L[R] N) (ι → M) N where
  coe f
```

-- snippet 4
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.continuousMapClass (L78-L82)
instance continuousMapClass : ContinuousMapClass (M [⋀^ι]→L[R] N) (ι → M) N where
  map_continuous f
```

-- snippet 5
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_continuous (L84-L85)
theorem coe_continuous : Continuous f
```

-- snippet 6
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_toContinuousMultilinearMap (L87-L89)
theorem coe_toContinuousMultilinearMap : ⇑f.toContinuousMultilinearMap = f
```

-- snippet 7
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_mk (L91-L95)
theorem coe_mk (f : ContinuousMultilinearMap R (fun _ : ι => M) N) (h) : ⇑(mk f h) = f
```

-- snippet 8
```lean
-- Mathlib.Topology.Algebra.Module.Alternating.Basic.coe_toAlternatingMap (L96-L97)
theorem coe_toAlternatingMap : ⇑f.toAlternatingMap = f
```

-- snippet 9
```lean
-- Mathlib.Topology.Algebra.Affine.isOpenMap_linear_iff (L46-L58)
theorem isOpenMap_linear_iff {f : P →ᵃ[R] Q} : IsOpenMap f.linear ↔ IsOpenMap f
```

-- snippet 10
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous_uncurry (L60-L65)
theorem lineMap_continuous_uncurry :
    Continuous (fun pqt : P × P × R ↦ lineMap pqt.1 pqt.2.1 pqt.2.2)
```

-- snippet 11
```lean
-- Mathlib.Topology.Algebra.Affine.lineMap_continuous (L66-L75)
theorem lineMap_continuous {p q : P} :
    Continuous (lineMap p q : R →ᵃ[R] P)
```

-- snippet 12
```lean
-- Mathlib.Topology.Algebra.Affine.continuous_linear_iff (L35-L45)
theorem continuous_linear_iff {f : P →ᵃ[R] Q} : Continuous f.linear ↔ Continuous f
```

-- snippet 13
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_isOpenMap (L146-L152)
theorem homothety_isOpenMap (x : P) (t : R) (ht : t ≠ 0) : IsOpenMap <| homothety x t
```

-- snippet 14
```lean
-- Mathlib.Topology.Algebra.Affine.homothety_continuous (L118-L125)
theorem homothety_continuous (x : P) (t : R) : Continuous <| homothety x t
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Order.Filter.Prod).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem mem_prod_principal {s : Set (α × β)} :
    s ∈ f ×ˢ 𝓟 t ↔ { a | ∀ b ∈ t, (a, b) ∈ s } ∈ f
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Order.Filter.Prod.prod_mem_prod (L49-L51)
theorem prod_mem_prod (hs : s ∈ f) (ht : t ∈ g) : s ×ˢ t ∈ f ×ˢ g
```

-- snippet 2
```lean
-- Mathlib.Order.Filter.Prod.mem_prod_iff (L52-L59)
theorem mem_prod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s
```

-- snippet 3
```lean
-- Mathlib.Order.Filter.Prod.compl_diagonal_mem_prod (L61-L63)
theorem compl_diagonal_mem_prod {l₁ l₂ : Filter α} : (diagonal α)ᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂
```

-- snippet 4
```lean
-- Mathlib.Order.Filter.Prod.prod_mem_prod_iff (L65-L73)
theorem prod_mem_prod_iff [f.NeBot] [g.NeBot] : s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g
```

-- snippet 5
```lean
-- Mathlib.Order.Filter.Prod.mem_prod_top (L83-L87)
theorem mem_prod_top {s : Set (α × β)} :
    s ∈ f ×ˢ (⊤ : Filter β) ↔ { a | ∀ b, (a, b) ∈ s } ∈ f
```

-- snippet 6
```lean
-- Mathlib.Order.Filter.Prod.eventually_prod_principal_iff (L88-L92)
theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y)
```

-- snippet 7
```lean
-- Mathlib.Order.Filter.Prod.comap_prod (L93-L96)
theorem comap_prod (f : α → β × γ) (b : Filter β) (c : Filter γ) :
    comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c
```

-- snippet 8
```lean
-- Mathlib.Order.Filter.Prod.comap_prodMap_prod (L97-L100)
theorem comap_prodMap_prod (f : α → β) (g : γ → δ) (lb : Filter β) (ld : Filter δ) :
    comap (Prod.map f g) (lb ×ˢ ld) = comap f lb ×ˢ comap g ld
```

-- snippet 9
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.PNat (L40-L43)
theorem PNat.tendsto_comp_val_iff {β : Type*} {f : ℕ → β} {l : Filter β} :
    Tendsto (fun x : ℕ+ => f x) atTop l ↔ Tendsto f atTop l
```

-- snippet 10
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_natCast_atTop_iff (L35-L39)
theorem tendsto_natCast_atTop_iff [Semiring R] [PartialOrder R] [IsStrictOrderedRing R]
    [Archimedean R] {f : α → ℕ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop
```

-- snippet 11
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_natCast_atTop_atTop (L44-L48)
theorem tendsto_natCast_atTop_atTop [Semiring R] [PartialOrder R] [IsOrderedRing R]
    [Archimedean R] :
    Tendsto ((↑) : ℕ → R) atTop atTop
```

-- snippet 12
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.Nat (L31-L34)
theorem Nat.comap_cast_atTop [Semiring R] [PartialOrder R] [IsStrictOrderedRing R] [Archimedean R] :
    comap ((↑) : ℕ → R) atTop = atTop
```

-- snippet 13
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_PNat_val_atTop_atTop (L49-L51)
lemma tendsto_PNat_val_atTop_atTop : Tendsto PNat.val atTop atTop
```

-- snippet 14
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.Filter (L52-L56)
theorem Filter.Eventually.natCast_atTop [Semiring R] [PartialOrder R] [IsOrderedRing R]
    [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℕ) in atTop, p n
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Order.Filter.Prod).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem mem_prod_principal {s : Set (α × β)} :
    s ∈ f ×ˢ 𝓟 t ↔ { a | ∀ b ∈ t, (a, b) ∈ s } ∈ f
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Order.Filter.Prod.prod_mem_prod (L49-L51)
theorem prod_mem_prod (hs : s ∈ f) (ht : t ∈ g) : s ×ˢ t ∈ f ×ˢ g
```

-- snippet 2
```lean
-- Mathlib.Order.Filter.Prod.mem_prod_iff (L52-L59)
theorem mem_prod_iff {s : Set (α × β)} {f : Filter α} {g : Filter β} :
    s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s
```

-- snippet 3
```lean
-- Mathlib.Order.Filter.Prod.compl_diagonal_mem_prod (L61-L63)
theorem compl_diagonal_mem_prod {l₁ l₂ : Filter α} : (diagonal α)ᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂
```

-- snippet 4
```lean
-- Mathlib.Order.Filter.Prod.prod_mem_prod_iff (L65-L73)
theorem prod_mem_prod_iff [f.NeBot] [g.NeBot] : s ×ˢ t ∈ f ×ˢ g ↔ s ∈ f ∧ t ∈ g
```

-- snippet 5
```lean
-- Mathlib.Order.Filter.Prod.mem_prod_top (L83-L87)
theorem mem_prod_top {s : Set (α × β)} :
    s ∈ f ×ˢ (⊤ : Filter β) ↔ { a | ∀ b, (a, b) ∈ s } ∈ f
```

-- snippet 6
```lean
-- Mathlib.Order.Filter.Prod.eventually_prod_principal_iff (L88-L92)
theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y)
```

-- snippet 7
```lean
-- Mathlib.Order.Filter.Prod.comap_prod (L93-L96)
theorem comap_prod (f : α → β × γ) (b : Filter β) (c : Filter γ) :
    comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c
```

-- snippet 8
```lean
-- Mathlib.Order.Filter.Prod.comap_prodMap_prod (L97-L100)
theorem comap_prodMap_prod (f : α → β) (g : γ → δ) (lb : Filter β) (ld : Filter δ) :
    comap (Prod.map f g) (lb ×ˢ ld) = comap f lb ×ˢ comap g ld
```

-- snippet 9
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.PNat (L40-L43)
theorem PNat.tendsto_comp_val_iff {β : Type*} {f : ℕ → β} {l : Filter β} :
    Tendsto (fun x : ℕ+ => f x) atTop l ↔ Tendsto f atTop l
```

-- snippet 10
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_natCast_atTop_iff (L35-L39)
theorem tendsto_natCast_atTop_iff [Semiring R] [PartialOrder R] [IsStrictOrderedRing R]
    [Archimedean R] {f : α → ℕ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop
```

-- snippet 11
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_natCast_atTop_atTop (L44-L48)
theorem tendsto_natCast_atTop_atTop [Semiring R] [PartialOrder R] [IsOrderedRing R]
    [Archimedean R] :
    Tendsto ((↑) : ℕ → R) atTop atTop
```

-- snippet 12
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.Nat (L31-L34)
theorem Nat.comap_cast_atTop [Semiring R] [PartialOrder R] [IsStrictOrderedRing R] [Archimedean R] :
    comap ((↑) : ℕ → R) atTop = atTop
```

-- snippet 13
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.tendsto_PNat_val_atTop_atTop (L49-L51)
lemma tendsto_PNat_val_atTop_atTop : Tendsto PNat.val atTop atTop
```

-- snippet 14
```lean
-- Mathlib.Order.Filter.AtTopBot.Archimedean.Filter (L52-L56)
theorem Filter.Eventually.natCast_atTop [Semiring R] [PartialOrder R] [IsOrderedRing R]
    [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℕ) in atTop, p n
```
[/INST]


[System] You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.LocallyConvex.Separation).

[User]
Prove the following theorem. The retrieved context below may help.

```lean
theorem iInter_countable_halfSpaces_eq [HereditarilyLindelofSpace E]
    (hs₁ : Convex ℝ s) (hs₂ : IsClosed s) :
    ∃ l : ℕ → StrongDual 𝕜 E, ∃ c : ℕ → ℝ, ⋂ n, { x | re (l n x) ≤ c n } = s
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.separate_convex_open_set (L54-L87)
theorem separate_convex_open_set [TopologicalSpace E] [AddCommGroup E] [IsTopologicalAddGroup E]
    [Module ℝ E] [ContinuousSMul ℝ E] {s : Set E} (hs₀ : (0 : E) ∈ s) (hs₁ : Convex ℝ s)
    (hs₂ : IsOpen s) {x₀ : E} (hx₀ : x₀ ∉ s) :
    ∃ f : StrongDual ℝ E, f x₀ = 1 ∧ ∀ x ∈ s, f x < 1
```

-- snippet 2
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open (L94-L123)
theorem geometric_hahn_banach_open (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (ht : Convex ℝ t)
    (disj : Disjoint s t) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a < u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 3
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open_point (L124-L129)
theorem geometric_hahn_banach_open_point (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (disj : x ∉ s) :
    ∃ f : StrongDual ℝ E, ∀ a ∈ s, f a < f x
```

-- snippet 4
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_point_open (L130-L134)
theorem geometric_hahn_banach_point_open (ht₁ : Convex ℝ t) (ht₂ : IsOpen t) (disj : x ∉ t) :
    ∃ f : StrongDual ℝ E, ∀ b ∈ t, f x < f b
```

-- snippet 5
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open_open (L135-L153)
theorem geometric_hahn_banach_open_open (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (ht₁ : Convex ℝ t)
    (ht₃ : IsOpen t) (disj : Disjoint s t) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a < u) ∧ ∀ b ∈ t, u < f b
```

-- snippet 6
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior (L154-L172)
theorem geometric_hahn_banach_of_nonempty_interior
  (hs : Convex ℝ s) (ht : Convex ℝ t) (hst : Disjoint (interior s) t)
    (hsint : (interior s).Nonempty) (htne : t.Nonempty) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), f ≠ 0 ∧ (∀ a ∈ s, f a ≤ u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 7
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior' (L173-L184)
theorem geometric_hahn_banach_of_nonempty_interior'
  (hs : Convex ℝ s) (ht : Convex ℝ t) (hst : Disjoint (interior s) t)
    (hsint : (interior s).Nonempty) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a ≤ u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 8
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior_point (L185-L196)
theorem geometric_hahn_banach_of_nonempty_interior_point
    {A : Set E} (hA : Convex ℝ A) (hxA : x ∉ interior A) (hAint : (interior A).Nonempty) :
    ∃ f : StrongDual ℝ E, f ≠ 0 ∧ ∀ a ∈ A, f a ≤ f x
```

-- snippet 9
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.absConvexHull (L79-L83)
def absConvexHull : ClosureOperator (Set E)
```

-- snippet 10
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.balanced_absConvexHull (L90-L92)
theorem balanced_absConvexHull : Balanced 𝕜 (absConvexHull 𝕜 s)
```

-- snippet 11
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.absConvex_absConvexHull (L87-L89)
theorem absConvex_absConvexHull : AbsConvex 𝕜 (absConvexHull 𝕜 s)
```

-- snippet 12
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.subset_absConvexHull (L84-L86)
theorem subset_absConvexHull : s ⊆ absConvexHull 𝕜 s
```

-- snippet 13
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.AbsConvex (L53-L56)
def AbsConvex (s : Set E) : Prop
```

-- snippet 14
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.convex_absConvexHull (L93-L96)
theorem convex_absConvexHull : Convex 𝕜 (absConvexHull 𝕜 s)
```

<s>[SYSTEM_PROMPT]You are Leanstral, a Lean 4 proof assistant. Complete the task below using the provided Lean source context. The target mathlib commit is 5e932f97dd25535344f80f9dd8da3aab83df0fe6 (module Mathlib.Analysis.LocallyConvex.Separation).[/SYSTEM_PROMPT][MODEL_SETTINGS]{"reasoning_effort": "none"}[/MODEL_SETTINGS][INST]Prove the following theorem. The retrieved context below may help.

```lean
theorem iInter_countable_halfSpaces_eq [HereditarilyLindelofSpace E]
    (hs₁ : Convex ℝ s) (hs₂ : IsClosed s) :
    ∃ l : ℕ → StrongDual 𝕜 E, ∃ c : ℕ → ℝ, ⋂ n, { x | re (l n x) ≤ c n } = s
```

## Retrieved context
-- snippet 1
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.separate_convex_open_set (L54-L87)
theorem separate_convex_open_set [TopologicalSpace E] [AddCommGroup E] [IsTopologicalAddGroup E]
    [Module ℝ E] [ContinuousSMul ℝ E] {s : Set E} (hs₀ : (0 : E) ∈ s) (hs₁ : Convex ℝ s)
    (hs₂ : IsOpen s) {x₀ : E} (hx₀ : x₀ ∉ s) :
    ∃ f : StrongDual ℝ E, f x₀ = 1 ∧ ∀ x ∈ s, f x < 1
```

-- snippet 2
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open (L94-L123)
theorem geometric_hahn_banach_open (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (ht : Convex ℝ t)
    (disj : Disjoint s t) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a < u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 3
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open_point (L124-L129)
theorem geometric_hahn_banach_open_point (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (disj : x ∉ s) :
    ∃ f : StrongDual ℝ E, ∀ a ∈ s, f a < f x
```

-- snippet 4
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_point_open (L130-L134)
theorem geometric_hahn_banach_point_open (ht₁ : Convex ℝ t) (ht₂ : IsOpen t) (disj : x ∉ t) :
    ∃ f : StrongDual ℝ E, ∀ b ∈ t, f x < f b
```

-- snippet 5
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_open_open (L135-L153)
theorem geometric_hahn_banach_open_open (hs₁ : Convex ℝ s) (hs₂ : IsOpen s) (ht₁ : Convex ℝ t)
    (ht₃ : IsOpen t) (disj : Disjoint s t) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a < u) ∧ ∀ b ∈ t, u < f b
```

-- snippet 6
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior (L154-L172)
theorem geometric_hahn_banach_of_nonempty_interior
  (hs : Convex ℝ s) (ht : Convex ℝ t) (hst : Disjoint (interior s) t)
    (hsint : (interior s).Nonempty) (htne : t.Nonempty) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), f ≠ 0 ∧ (∀ a ∈ s, f a ≤ u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 7
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior' (L173-L184)
theorem geometric_hahn_banach_of_nonempty_interior'
  (hs : Convex ℝ s) (ht : Convex ℝ t) (hst : Disjoint (interior s) t)
    (hsint : (interior s).Nonempty) :
    ∃ (f : StrongDual ℝ E) (u : ℝ), (∀ a ∈ s, f a ≤ u) ∧ ∀ b ∈ t, u ≤ f b
```

-- snippet 8
```lean
-- Mathlib.Analysis.LocallyConvex.Separation.geometric_hahn_banach_of_nonempty_interior_point (L185-L196)
theorem geometric_hahn_banach_of_nonempty_interior_point
    {A : Set E} (hA : Convex ℝ A) (hxA : x ∉ interior A) (hAint : (interior A).Nonempty) :
    ∃ f : StrongDual ℝ E, f ≠ 0 ∧ ∀ a ∈ A, f a ≤ f x
```

-- snippet 9
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.absConvexHull (L79-L83)
def absConvexHull : ClosureOperator (Set E)
```

-- snippet 10
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.balanced_absConvexHull (L90-L92)
theorem balanced_absConvexHull : Balanced 𝕜 (absConvexHull 𝕜 s)
```

-- snippet 11
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.absConvex_absConvexHull (L87-L89)
theorem absConvex_absConvexHull : AbsConvex 𝕜 (absConvexHull 𝕜 s)
```

-- snippet 12
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.subset_absConvexHull (L84-L86)
theorem subset_absConvexHull : s ⊆ absConvexHull 𝕜 s
```

-- snippet 13
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.AbsConvex (L53-L56)
def AbsConvex (s : Set E) : Prop
```

-- snippet 14
```lean
-- Mathlib.Analysis.LocallyConvex.AbsConvex.convex_absConvexHull (L93-L96)
theorem convex_absConvexHull : Convex 𝕜 (absConvexHull 𝕜 s)
```
[/INST]