1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LinearMap.isCompl_iSup_ker_pow_iInf_range_pow
File: Mathlib/RingTheory/Artinian.lean

tactic: obtain ⟨k, hk⟩ := eventually_atTop.mp <| f.eventually_isCompl_ker_pow_range_pow.and <|
  f.eventually_iInf_range_pow_eq.and f.eventually_iSup_ker_pow_eq
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: case intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))

tactic: obtain ⟨h₁, h₂, h₃⟩ := hk k (le_refl k)
state_before: case intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: case intro.intro.intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
h₁ : IsCompl (ker (f ^ k)) (range (f ^ k))
h₂ : ⨅ m, range (f ^ m) = range (f ^ k)
h₃ : ⨆ m, ker (f ^ m) = ker (f ^ k)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))

tactic: rwa [h₂, h₃]
state_before: case intro.intro.intro
R : Type u_1
M : Type u_2
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsArtinian R M
inst✝ : IsNoetherian R M
f : M →ₗ[R] M
k : ℕ
hk :
  ∀ b ≥ k, IsCompl (ker (f ^ b)) (range (f ^ b)) ∧ ⨅ m, range (f ^ m) = range (f ^ b) ∧ ⨆ m, ker (f ^ m) = ker (f ^ b)
h₁ : IsCompl (ker (f ^ k)) (range (f ^ k))
h₂ : ⨅ m, range (f ^ m) = range (f ^ k)
h₃ : ⨆ m, ker (f ^ m) = ker (f ^ k)
⊢ IsCompl (⨆ n, ker (f ^ n)) (⨅ n, range (f ^ n))
state_after: no goals
Theorem: UpperHalfPlane.modular_T_smul
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

tactic: simpa only [Int.cast_one] using modular_T_zpow_smul z 1
state_before: z : ℍ
⊢ ModularGroup.T • z = 1 +ᵥ z
state_after: no goals
Theorem: Order.Ideal.PrimePair.I_isProper
File: Mathlib/Order/PrimeIdeal.lean

tactic: cases' IF.F.nonempty with w h
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
⊢ IF.I.IsProper
state_after: case intro
P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ IF.I.IsProper

tactic: apply isProper_of_not_mem (_ : w ∉ IF.I)
state_before: case intro
P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ IF.I.IsProper
state_after: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ w ∉ IF.I

tactic: rwa [← IF.compl_I_eq_F] at h
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
w : P
h : w ∈ ↑IF.F
⊢ w ∉ IF.I
state_after: no goals
Theorem: FractionalIdeal.inv_le_comm
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: simpa using le_inv_comm (A := A) (K := K) (inv_ne_zero hI) (inv_ne_zero hJ)
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : FractionalIdeal A⁰ K
hI : I ≠ 0
hJ : J ≠ 0
⊢ I⁻¹ ≤ J ↔ J⁻¹ ≤ I
state_after: no goals
Theorem: Asymptotics.IsLittleO.eventuallyLE
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa using h.def zero_lt_one
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
h : f =o[l] g
⊢ ∀ᶠ (x : α) in l, ‖f x‖ ≤ ‖g x‖
state_after: no goals
Theorem: Cardinal.mk_bounded_set_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: trans #{ t : Set (Sum (ULift.{u} ℕ) α) // #t ≤ c }
state_before: α : Type u
c : Cardinal.{u}
⊢ #{ t // #↑t ≤ c } ≤ max #α ℵ₀ ^ c
state_after: α : Type u
c : Cardinal.{u}
⊢ #{ t // #↑t ≤ c } ≤ #{ t // #↑t ≤ c }

α : Type u
c : Cardinal.{u}
⊢ #{ t // #↑t ≤ c } ≤ max #α ℵ₀ ^ c

tactic: apply (mk_bounded_set_le_of_infinite (Sum (ULift.{u} ℕ) α) c).trans
state_before: α : Type u
c : Cardinal.{u}
⊢ #{ t // #↑t ≤ c } ≤ max #α ℵ₀ ^ c
state_after: α : Type u
c : Cardinal.{u}
⊢ #(ULift.{u, 0} ℕ ⊕ α) ^ c ≤ max #α ℵ₀ ^ c

tactic: rw [max_comm, ← add_eq_max] <;> rfl
state_before: α : Type u
c : Cardinal.{u}
⊢ #(ULift.{u, 0} ℕ ⊕ α) ^ c ≤ max #α ℵ₀ ^ c
state_after: no goals

tactic: refine ⟨Embedding.subtypeMap ?_ ?_⟩
state_before: α : Type u
c : Cardinal.{u}
⊢ #{ t // #↑t ≤ c } ≤ #{ t // #↑t ≤ c }
state_after: case refine_1
α : Type u
c : Cardinal.{u}
⊢ Set α ↪ Set (ULift.{u, 0} ℕ ⊕ α)

case refine_2
α : Type u
c : Cardinal.{u}
⊢ ∀ ⦃x : Set α⦄, #↑x ≤ c → #↑(?refine_1 x) ≤ c

tactic: intro s hs
state_before: case refine_2
α : Type u
c : Cardinal.{u}
⊢ ∀ ⦃x : Set α⦄, #↑x ≤ c → #↑({ toFun := Sum.inr, inj' := ⋯ }.image x) ≤ c
state_after: case refine_2
α : Type u
c : Cardinal.{u}
s : Set α
hs : #↑s ≤ c
⊢ #↑({ toFun := Sum.inr, inj' := ⋯ }.image s) ≤ c

tactic: exact mk_image_le.trans hs
state_before: case refine_2
α : Type u
c : Cardinal.{u}
s : Set α
hs : #↑s ≤ c
⊢ #↑({ toFun := Sum.inr, inj' := ⋯ }.image s) ≤ c
state_after: no goals

tactic: apply Embedding.image
state_before: case refine_1
α : Type u
c : Cardinal.{u}
⊢ Set α ↪ Set (ULift.{u, 0} ℕ ⊕ α)
state_after: case refine_1.f
α : Type u
c : Cardinal.{u}
⊢ α ↪ ULift.{u, 0} ℕ ⊕ α

tactic: use Sum.inr
state_before: case refine_1.f
α : Type u
c : Cardinal.{u}
⊢ α ↪ ULift.{u, 0} ℕ ⊕ α
state_after: case inj'
α : Type u
c : Cardinal.{u}
⊢ Injective Sum.inr

tactic: apply Sum.inr.inj
state_before: case inj'
α : Type u
c : Cardinal.{u}
⊢ Injective Sum.inr
state_after: no goals
Theorem: biSup_sup
File: Mathlib/Order/CompleteLattice.lean

tactic: haveI : Nonempty { i // p i } :=
  let ⟨i, hi⟩ := h
  ⟨⟨i, hi⟩⟩
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
this : Nonempty { i // p i }
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a

tactic: rw [iSup_subtype', iSup_subtype', iSup_sup]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
this : Nonempty { i // p i }
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a
state_after: no goals
Theorem: inseparable_iff_mem_closure
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [specializes_iff_mem_closure, and_comm]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
⊢ x ⤳ y ∧ y ⤳ x ↔ x ∈ closure {y} ∧ y ∈ closure {x}
state_after: no goals
Theorem: mul_inv_le_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, inv_mul_le_iff h]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a * b⁻¹ ≤ c ↔ a ≤ b * c
state_after: no goals
Theorem: ArithmeticFunction.pmul_comm
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f g : ArithmeticFunction R
⊢ f.pmul g = g.pmul f
state_after: case h
R : Type u_1
inst✝ : CommMonoidWithZero R
f g : ArithmeticFunction R
x✝ : ℕ
⊢ (f.pmul g) x✝ = (g.pmul f) x✝

tactic: simp [mul_comm]
state_before: case h
R : Type u_1
inst✝ : CommMonoidWithZero R
f g : ArithmeticFunction R
x✝ : ℕ
⊢ (f.pmul g) x✝ = (g.pmul f) x✝
state_after: no goals
Theorem: Submonoid.mem_sSup_of_mem
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: rw [← SetLike.le_def]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
s : Submonoid M
hs : s ∈ S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
s : Submonoid M
hs : s ∈ S
⊢ s ≤ sSup S

tactic: exact le_sSup hs
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
S : Set (Submonoid M)
s : Submonoid M
hs : s ∈ S
⊢ s ≤ sSup S
state_after: no goals
Theorem: MeasureTheory.memℒp_map_measure_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [Memℒp, snorm_map_measure hg hf, hg.comp_aemeasurable hf, hg]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
β : Type u_5
mβ : MeasurableSpace β
f : α → β
g : β → E
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
⊢ Memℒp g p (Measure.map f μ) ↔ Memℒp (g ∘ f) p μ
state_after: no goals
Theorem: Multiset.bind_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → Multiset γ
⊢ (bind 0 fun a => n.bind fun b => f a b) = n.bind fun b => bind 0 fun a => f a b
state_after: no goals

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → Multiset γ
⊢ ∀ (a : α) (s : Multiset α),
    ((s.bind fun a => n.bind fun b => f a b) = n.bind fun b => s.bind fun a => f a b) →
      ((a ::ₘ s).bind fun a => n.bind fun b => f a b) = n.bind fun b => (a ::ₘ s).bind fun a => f a b
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_singularPart
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [rnDeriv_eq_zero]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ (μ.singularPart ν).rnDeriv ν =ᶠ[ae ν] 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ μ.singularPart ν ⟂ₘ ν

tactic: exact mutuallySingular_singularPart μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ μ.singularPart ν ⟂ₘ ν
state_after: no goals
Theorem: Ordinal.lt_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← not_le, div_le h, not_lt]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : c ≠ 0
⊢ a < b / c ↔ c * succ a ≤ b
state_after: no goals
Theorem: skewAdjoint.conjugate'
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [mem_iff, star_mul, star_star, mem_iff.mp hx, neg_mul, mul_neg, mul_assoc]
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
z : R
⊢ star z * x * z ∈ skewAdjoint R
state_after: no goals
Theorem: EqualCharZero.nonempty_algebraRat_iff
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : CommRing R
⊢ Nonempty (Algebra ℚ R) ↔ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
state_after: case mp
R : Type u_1
inst✝ : CommRing R
⊢ Nonempty (Algebra ℚ R) → ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

case mpr
R : Type u_1
inst✝ : CommRing R
⊢ (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)) → Nonempty (Algebra ℚ R)

tactic: intro h_alg
state_before: case mp
R : Type u_1
inst✝ : CommRing R
⊢ Nonempty (Algebra ℚ R) → ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
state_after: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: haveI h_alg' : Algebra ℚ R := h_alg.some
state_before: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
state_after: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
h_alg' : Algebra ℚ R
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: apply of_algebraRat
state_before: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
h_alg' : Algebra ℚ R
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
state_after: no goals

tactic: intro h
state_before: case mpr
R : Type u_1
inst✝ : CommRing R
⊢ (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)) → Nonempty (Algebra ℚ R)
state_after: case mpr
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Nonempty (Algebra ℚ R)

tactic: apply Nonempty.intro
state_before: case mpr
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Nonempty (Algebra ℚ R)
state_after: case mpr.val
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Algebra ℚ R

tactic: exact algebraRat h
state_before: case mpr.val
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Algebra ℚ R
state_after: no goals
Theorem: Multipliable.hasProd_iff_tendsto_nat
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

tactic: refine ⟨fun h ↦ h.tendsto_prod_nat, fun h ↦ ?_⟩
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : T2Space M
f : ℕ → M
hf : Multipliable f
⊢ HasProd f m ↔ Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : T2Space M
f : ℕ → M
hf : Multipliable f
h : Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)
⊢ HasProd f m

tactic: rw [tendsto_nhds_unique h hf.hasProd.tendsto_prod_nat]
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : T2Space M
f : ℕ → M
hf : Multipliable f
h : Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)
⊢ HasProd f m
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : T2Space M
f : ℕ → M
hf : Multipliable f
h : Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)
⊢ HasProd f (∏' (b : ℕ), f b)

tactic: exact hf.hasProd
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : T2Space M
f : ℕ → M
hf : Multipliable f
h : Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)
⊢ HasProd f (∏' (b : ℕ), f b)
state_after: no goals
Theorem: DFinsupp.filter_add
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → AddZeroClass (β i)
p : ι → Prop
inst✝ : DecidablePred p
f g : Π₀ (i : ι), β i
⊢ filter p (f + g) = filter p f + filter p g
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → AddZeroClass (β i)
p : ι → Prop
inst✝ : DecidablePred p
f g : Π₀ (i : ι), β i
i✝ : ι
⊢ (filter p (f + g)) i✝ = (filter p f + filter p g) i✝

tactic: simp [ite_add_zero]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → AddZeroClass (β i)
p : ι → Prop
inst✝ : DecidablePred p
f g : Π₀ (i : ι), β i
i✝ : ι
⊢ (filter p (f + g)) i✝ = (filter p f + filter p g) i✝
state_after: no goals
Theorem: MeasureTheory.sigmaFiniteTrim_mono
File: Mathlib/MeasureTheory/Measure/Trim.lean

tactic: refine ⟨⟨?_⟩⟩
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ SigmaFinite (μ.trim hm)
state_after: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ (μ.trim hm).FiniteSpanningSetsIn Set.univ

tactic: refine
  { set := spanningSets (μ.trim (hm₂.trans hm))
    set_mem := fun _ => Set.mem_univ _
    finite := fun i => ?_
    spanning := iUnion_spanningSets _ }
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ (μ.trim hm).FiniteSpanningSetsIn Set.univ
state_after: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ (μ.trim hm) (spanningSets (μ.trim ⋯) i) < ⊤

tactic: calc
  (μ.trim hm) (spanningSets (μ.trim (hm₂.trans hm)) i) =
      ((μ.trim hm).trim hm₂) (spanningSets (μ.trim (hm₂.trans hm)) i) := by
    rw [@trim_measurableSet_eq α m₂ m (μ.trim hm) _ hm₂ (measurable_spanningSets _ _)]
  _ = (μ.trim (hm₂.trans hm)) (spanningSets (μ.trim (hm₂.trans hm)) i) := by
    rw [@trim_trim _ _ μ _ _ hm₂ hm]
  _ < ∞ := measure_spanningSets_lt_top _ _
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ (μ.trim hm) (spanningSets (μ.trim ⋯) i) < ⊤
state_after: no goals

tactic: rw [@trim_measurableSet_eq α m₂ m (μ.trim hm) _ hm₂ (measurable_spanningSets _ _)]
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ (μ.trim hm) (spanningSets (μ.trim ⋯) i) = ((μ.trim hm).trim hm₂) (spanningSets (μ.trim ⋯) i)
state_after: no goals

tactic: rw [@trim_trim _ _ μ _ _ hm₂ hm]
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ ((μ.trim hm).trim hm₂) (spanningSets (μ.trim ⋯) i) = (μ.trim ⋯) (spanningSets (μ.trim ⋯) i)
state_after: no goals
Theorem: Set.Finite.toFinset_range
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
⊢ h.toFinset = Finset.image f Finset.univ
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f Finset.univ

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f Finset.univ
state_after: no goals
Theorem: one_le_pow_of_one_le'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

tactic: simp
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
H : 1 ≤ a
⊢ 1 ≤ a ^ 0
state_after: no goals

tactic: rw [pow_succ]
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
H : 1 ≤ a
k : ℕ
⊢ 1 ≤ a ^ (k + 1)
state_after: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
H : 1 ≤ a
k : ℕ
⊢ 1 ≤ a ^ k * a

tactic: exact one_le_mul (one_le_pow_of_one_le' H k) H
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
H : 1 ≤ a
k : ℕ
⊢ 1 ≤ a ^ k * a
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.comp_appLE
File: Mathlib/AlgebraicGeometry/Scheme.lean

tactic: rw [g.app_eq_appLE, appLE_comp_appLE]
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
U : Opens ↑↑Z.toPresheafedSpace
V : Opens ↑↑X.toPresheafedSpace
e : V ≤ (f ≫ g) ⁻¹ᵁ U
⊢ Hom.appLE (f ≫ g) U V e = Hom.app g U ≫ Hom.appLE f (g ⁻¹ᵁ U) V e
state_after: no goals
Theorem: pow_eq_pow_iff_cases
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rcases eq_or_ne n 0 with rfl | hn <;> simp [pow_eq_pow_iff_of_ne_zero, *]
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
⊢ a ^ n = b ^ n ↔ n = 0 ∨ a = b ∨ a = -b ∧ Even n
state_after: no goals
Theorem: Nat.add_div_of_dvd_left
File: Mathlib/Data/Nat/ModEq.lean

tactic: rwa [add_comm, Nat.add_div_of_dvd_right, add_comm]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hca : c ∣ b
⊢ (a + b) / c = a / c + b / c
state_after: no goals
Theorem: Matroid.Basis.basis_union_of_subset
File: Mathlib/Data/Matroid/Basic.lean

tactic: convert hJ.basis_self.union_basis_union hI _ <;>
rw [union_eq_self_of_subset_right hIJ]
state_before: α : Type u_1
M : Matroid α
I X J : Set α
hI : M.Basis I X
hJ : M.Indep J
hIJ : I ⊆ J
⊢ M.Basis J (J ∪ X)
state_after: α : Type u_1
M : Matroid α
I X J : Set α
hI : M.Basis I X
hJ : M.Indep J
hIJ : I ⊆ J
⊢ M.Indep J

tactic: assumption
state_before: α : Type u_1
M : Matroid α
I X J : Set α
hI : M.Basis I X
hJ : M.Indep J
hIJ : I ⊆ J
⊢ M.Indep J
state_after: no goals
Theorem: NonUnitalAlgHom.to_mulHom_injective
File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

tactic: ext a
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
⊢ f = g
state_after: case h
R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
a : A
⊢ f a = g a

tactic: exact DFunLike.congr_fun h a
state_before: case h
R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
a : A
⊢ f a = g a
state_after: no goals