1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Primrec.option_iget
File: Mathlib/Computability/Primrec.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
inst✝ : Inhabited α
o : Option α
⊢ (Option.casesOn (id o) default fun b => b) = o.iget
state_after: no goals
Theorem: Set.star_add
File: Mathlib/Algebra/Star/Pointwise.lean

tactic: simp_rw [← image_star, ← image2_add, image_image2, image2_image_left, image2_image_right,
  star_add]
state_before: α : Type u_1
s✝ t✝ : Set α
a : α
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
s t : Set α
⊢ (s + t)⋆ = s⋆ + t⋆
state_after: no goals
Theorem: jacobiTheta_T_sq_smul
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

tactic: suffices (ModularGroup.T ^ 2 • τ :) = (2 : ℂ) + ↑τ by simp_rw [this, jacobiTheta_two_add]
state_before: τ : ℍ
⊢ jacobiTheta ↑(ModularGroup.T ^ 2 • τ) = jacobiTheta ↑τ
state_after: τ : ℍ
⊢ ↑(ModularGroup.T ^ 2 • τ) = 2 + ↑τ

tactic: have : ModularGroup.T ^ (2 : ℕ) = ModularGroup.T ^ (2 : ℤ) := rfl
state_before: τ : ℍ
⊢ ↑(ModularGroup.T ^ 2 • τ) = 2 + ↑τ
state_after: τ : ℍ
this : ModularGroup.T ^ 2 = ModularGroup.T ^ 2
⊢ ↑(ModularGroup.T ^ 2 • τ) = 2 + ↑τ

tactic: simp_rw [this, UpperHalfPlane.modular_T_zpow_smul, UpperHalfPlane.coe_vadd]
state_before: τ : ℍ
this : ModularGroup.T ^ 2 = ModularGroup.T ^ 2
⊢ ↑(ModularGroup.T ^ 2 • τ) = 2 + ↑τ
state_after: τ : ℍ
this : ModularGroup.T ^ 2 = ModularGroup.T ^ 2
⊢ ↑↑2 + ↑τ = 2 + ↑τ

tactic: norm_cast
state_before: τ : ℍ
this : ModularGroup.T ^ 2 = ModularGroup.T ^ 2
⊢ ↑↑2 + ↑τ = 2 + ↑τ
state_after: no goals

tactic: simp_rw [this, jacobiTheta_two_add]
state_before: τ : ℍ
this : ↑(ModularGroup.T ^ 2 • τ) = 2 + ↑τ
⊢ jacobiTheta ↑(ModularGroup.T ^ 2 • τ) = jacobiTheta ↑τ
state_after: no goals
Theorem: Quiver.reverse_reverse
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

tactic: apply h.inv'
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
f : a ⟶ b
⊢ reverse (reverse f) = f
state_after: no goals
Theorem: Nat.mul_lt_mul''
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hac : a < c
hbd : b < d
⊢ 0 < d
state_after: no goals
Theorem: HasStrictDerivAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: rw [div_eq_inv_mul]
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) (f' / f x) x
state_after: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') x

tactic: exact (hasStrictDerivAt_log hx).comp x hf
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') x
state_after: no goals
Theorem: Nat.size_pow
File: Mathlib/Data/Nat/Size.lean

tactic: decide
state_before: n : ℕ
⊢ 1 < 2
state_after: no goals
Theorem: Filter.coprod_bot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp [Filter.coprod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
l : Filter α
⊢ l.coprod ⊥ = comap Prod.fst l
state_after: no goals
Theorem: Real.Gamma_integrand_isLittleO
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: refine isLittleO_of_tendsto (fun x hx => ?_) ?_
state_before: s : ℝ
⊢ (fun x => rexp (-x) * x ^ s) =o[atTop] fun x => rexp (-(1 / 2) * x)
state_after: case refine_1
s x : ℝ
hx : rexp (-(1 / 2) * x) = 0
⊢ rexp (-x) * x ^ s = 0

case refine_2
s : ℝ
⊢ Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (𝓝 0)

tactic: have : (fun x : ℝ => exp (-x) * x ^ s / exp (-(1 / 2) * x)) =
    (fun x : ℝ => exp (1 / 2 * x) / x ^ s)⁻¹ := by
  ext1 x
  field_simp [exp_ne_zero, exp_neg, ← Real.exp_add]
  left
  ring
state_before: case refine_2
s : ℝ
⊢ Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (𝓝 0)
state_after: case refine_2
s : ℝ
this : (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹
⊢ Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (𝓝 0)

tactic: rw [this]
state_before: case refine_2
s : ℝ
this : (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹
⊢ Tendsto (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) atTop (𝓝 0)
state_after: case refine_2
s : ℝ
this : (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹
⊢ Tendsto (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹ atTop (𝓝 0)

tactic: exact (tendsto_exp_mul_div_rpow_atTop s (1 / 2) one_half_pos).inv_tendsto_atTop
state_before: case refine_2
s : ℝ
this : (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹
⊢ Tendsto (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹ atTop (𝓝 0)
state_after: no goals

tactic: exfalso
state_before: case refine_1
s x : ℝ
hx : rexp (-(1 / 2) * x) = 0
⊢ rexp (-x) * x ^ s = 0
state_after: case refine_1
s x : ℝ
hx : rexp (-(1 / 2) * x) = 0
⊢ False

tactic: exact (exp_pos (-(1 / 2) * x)).ne' hx
state_before: case refine_1
s x : ℝ
hx : rexp (-(1 / 2) * x) = 0
⊢ False
state_after: no goals

tactic: ext1 x
state_before: s : ℝ
⊢ (fun x => rexp (-x) * x ^ s / rexp (-(1 / 2) * x)) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹
state_after: case h
s x : ℝ
⊢ rexp (-x) * x ^ s / rexp (-(1 / 2) * x) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹ x

tactic: field_simp [exp_ne_zero, exp_neg, ← Real.exp_add]
state_before: case h
s x : ℝ
⊢ rexp (-x) * x ^ s / rexp (-(1 / 2) * x) = (fun x => rexp (1 / 2 * x) / x ^ s)⁻¹ x
state_after: case h
s x : ℝ
⊢ x = x * 2 + -x ∨ x ^ s = 0

tactic: left
state_before: case h
s x : ℝ
⊢ x = x * 2 + -x ∨ x ^ s = 0
state_after: case h.h
s x : ℝ
⊢ x = x * 2 + -x

tactic: ring
state_before: case h.h
s x : ℝ
⊢ x = x * 2 + -x
state_after: no goals
Theorem: Fin.univ_castSuccEmb
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ last n ∉ map castSuccEmb univ
state_after: no goals

tactic: simp [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ univ = Finset.cons (last n) (map castSuccEmb univ) ⋯
state_after: no goals
Theorem: CategoryTheory.Abelian.Exact.op
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: rw [exact_iff]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ Exact g.op f.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ g.op ≫ f.op = 0 ∧ kernel.ι f.op ≫ cokernel.π g.op = 0

tactic: refine ⟨by simp [← op_comp, h.w], Quiver.Hom.unop_inj ?_⟩
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ g.op ≫ f.op = 0 ∧ kernel.ι f.op ≫ cokernel.π g.op = 0
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ (kernel.ι f.op ≫ cokernel.π g.op).unop = Quiver.Hom.unop 0

tactic: simp only [unop_comp, cokernel.π_op, eqToHom_refl, kernel.ι_op, Category.id_comp,
  Category.assoc, kernel_comp_cokernel_assoc _ _ h, zero_comp, comp_zero, unop_zero]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ (kernel.ι f.op ≫ cokernel.π g.op).unop = Quiver.Hom.unop 0
state_after: no goals

tactic: simp [← op_comp, h.w]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : Exact f g
⊢ g.op ≫ f.op = 0
state_after: no goals
Theorem: alternatingGroup.nontrivial_of_three_le_card
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

tactic: haveI := Fintype.one_lt_card_iff_nontrivial.1 (lt_trans (by decide) h3)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
⊢ Nontrivial ↥(alternatingGroup α)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ Nontrivial ↥(alternatingGroup α)

tactic: rw [← Fintype.one_lt_card_iff_nontrivial]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ Nontrivial ↥(alternatingGroup α)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ 1 < card ↥(alternatingGroup α)

tactic: refine lt_of_mul_lt_mul_left ?_ (le_of_lt Nat.prime_two.pos)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ 1 < card ↥(alternatingGroup α)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ 2 * 1 < 2 * card ↥(alternatingGroup α)

tactic: rw [two_mul_card_alternatingGroup, card_perm, ← Nat.succ_le_iff]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ 2 * 1 < 2 * card ↥(alternatingGroup α)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ (2 * 1).succ ≤ (card α).factorial

tactic: exact le_trans h3 (card α).self_le_factorial
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
this : Nontrivial α
⊢ (2 * 1).succ ≤ (card α).factorial
state_after: no goals

tactic: decide
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
h3 : 3 ≤ card α
⊢ 1 < 2
state_after: no goals
Theorem: Finset.mulEnergy_empty_right
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp [mulEnergy]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ Eₘ[s, ∅] = 0
state_after: no goals
Theorem: Subgroup.subtype_range
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [range_eq_map, ← SetLike.coe_set_eq, coe_map, Subgroup.coeSubtype]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
⊢ H.subtype.range = H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
⊢ Subtype.val '' ↑⊤ = ↑H

tactic: ext
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
⊢ Subtype.val '' ↑⊤ = ↑H
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
x✝ : G
⊢ x✝ ∈ Subtype.val '' ↑⊤ ↔ x✝ ∈ ↑H

tactic: simp
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
x✝ : G
⊢ x✝ ∈ Subtype.val '' ↑⊤ ↔ x✝ ∈ ↑H
state_after: no goals
Theorem: Real.volume_Ioi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
n : ℕ
⊢ ↑n = volume (Ioo a (a + ↑n))
state_after: no goals
Theorem: star_div'
File: Mathlib/Algebra/Star/Basic.lean

tactic: apply op_injective
state_before: R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ star (x / y) = star x / star y
state_after: case a
R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ op (star (x / y)) = op (star x / star y)

tactic: rw [division_def, op_div, mul_comm, star_mul, star_inv', op_mul, op_inv]
state_before: case a
R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ op (star (x / y)) = op (star x / star y)
state_after: no goals
Theorem: Finset.card_Ioo_finset
File: Mathlib/Data/Finset/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc_finset h]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ (Ioo s t).card = 2 ^ (t.card - s.card) - 2
state_after: no goals
Theorem: Int.exists_least_of_bdd
File: Mathlib/Data/Int/LeastGreatest.lean

tactic: classical
let ⟨b , Hb⟩ := Hbdd
let ⟨lb , H⟩ := leastOfBdd b Hb Hinh
exact ⟨lb , H⟩
state_before: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
state_after: no goals

tactic: let ⟨b , Hb⟩ := Hbdd
state_before: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
state_after: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z

tactic: let ⟨lb , H⟩ := leastOfBdd b Hb Hinh
state_before: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
state_after: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
lb : ℤ
H : P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z

tactic: exact ⟨lb , H⟩
state_before: P : ℤ → Prop
Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z
Hinh : ∃ z, P z
b : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
lb : ℤ
H : P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
⊢ ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.support_eq
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [mem_support, Set.mem_preimage, mem_filter, mem_range_self, true_and_iff, exists_prop,
  mem_iUnion, Set.mem_range, mem_singleton_iff, exists_eq_right']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : Zero β
f : α →ₛ β
x : α
⊢ x ∈ support ↑f ↔ x ∈ ⋃ y ∈ filter (fun y => y ≠ 0) f.range, ↑f ⁻¹' {y}
state_after: no goals
Theorem: Submodule.map_le_smul_top
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
⊢ map f I ≤ I • ⊤
state_after: case intro.intro
R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ f y ∈ I • ⊤

tactic: rw [← mul_one y, ← smul_eq_mul, f.map_smul]
state_before: case intro.intro
R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ f y ∈ I • ⊤
state_after: case intro.intro
R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ y • f 1 ∈ I • ⊤

tactic: exact smul_mem_smul hy mem_top
state_before: case intro.intro
R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
f : R →ₗ[R] M
y : R
hy : y ∈ ↑I
⊢ y • f 1 ∈ I • ⊤
state_after: no goals
Theorem: Cardinal.lift_iSup_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [lift_iSup hf]
state_before: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
t : Cardinal.{max u w}
hf : BddAbove (range f)
w : ∀ (i : ι), lift.{u, w} (f i) ≤ t
⊢ lift.{u, w} (iSup f) ≤ t
state_after: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
t : Cardinal.{max u w}
hf : BddAbove (range f)
w : ∀ (i : ι), lift.{u, w} (f i) ≤ t
⊢ ⨆ i, lift.{u, w} (f i) ≤ t

tactic: exact ciSup_le' w
state_before: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
t : Cardinal.{max u w}
hf : BddAbove (range f)
w : ∀ (i : ι), lift.{u, w} (f i) ≤ t
⊢ ⨆ i, lift.{u, w} (f i) ≤ t
state_after: no goals
Theorem: List.erase_diff_erase_sublist_of_sublist
File: Mathlib/Data/List/Basic.lean

tactic: simp only [heq, erase_cons_head, diff_cons]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff ((b :: l₁).erase a) <+ l₂.diff (b :: l₁)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff l₁ <+ (l₂.erase a).diff l₁

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ (l₂.erase a).diff l₁ <+ (l₂.erase a).diff l₁
state_after: no goals

tactic: simp only [erase_cons_head b l₁, erase_cons_tail l₁ (not_beq_of_ne heq),
  diff_cons ((List.erase l₂ a)) (List.erase l₁ a) b, diff_cons l₂ l₁ b, erase_comm a b l₂]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ (l₂.erase a).diff ((b :: l₁).erase a) <+ l₂.diff (b :: l₁)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁

tactic: have h' := h.erase b
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : (b :: l₁).erase b <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁

tactic: rw [erase_cons_head] at h'
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : (b :: l₁).erase b <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : l₁ <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁

tactic: exact @erase_diff_erase_sublist_of_sublist _ l₁ (l₂.erase b) h'
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : l₁ <+ l₂.erase b
⊢ ((l₂.erase b).erase a).diff (l₁.erase a) <+ (l₂.erase b).diff l₁
state_after: no goals
Theorem: LinearPMap.IsFormalAdjoint.symm
File: Mathlib/Analysis/InnerProductSpace/LinearPMap.lean

tactic: rw [← inner_conj_symm, ← inner_conj_symm (y : F), h]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
h : T.IsFormalAdjoint S
y : ↥S.domain
x✝ : ↥T.domain
⊢ ⟪↑S y, ↑x✝⟫_𝕜 = ⟪↑y, ↑T x✝⟫_𝕜
state_after: no goals
Theorem: tangentBundle_model_space_coe_chartAt_symm
File: Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean

tactic: rw [← PartialHomeomorph.coe_coe, PartialHomeomorph.symm_toPartialEquiv,
  tangentBundle_model_space_chartAt]
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : TangentBundle I H
⊢ ↑(chartAt (ModelProd H E) p).symm = ⇑(TotalSpace.toProd H E).symm
state_after: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : TangentBundle I H
⊢ ↑(TotalSpace.toProd H E).toPartialEquiv.symm = ⇑(TotalSpace.toProd H E).symm

tactic: rfl
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : TangentBundle I H
⊢ ↑(TotalSpace.toProd H E).toPartialEquiv.symm = ⇑(TotalSpace.toProd H E).symm
state_after: no goals
Theorem: Filter.Tendsto.div
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ hy)
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
f g : α → G₀
l : Filter α
a b : G₀
hf : Tendsto f l (𝓝 a)
hg : Tendsto g l (𝓝 b)
hy : b ≠ 0
⊢ Tendsto (f / g) l (𝓝 (a / b))
state_after: no goals
Theorem: MeasureTheory.L1.SimpleFunc.integral_eq_lintegral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [integral, SimpleFunc.integral_eq_lintegral (SimpleFunc.integrable f) h_pos]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace ℝ E
inst✝² : SMulCommClass ℝ 𝕜 E
F' : Type u_5
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
f : ↥(simpleFunc ℝ 1 μ)
h_pos : 0 ≤ᶠ[ae μ] ↑(toSimpleFunc f)
⊢ integral f = (∫⁻ (a : α), ENNReal.ofReal (↑(toSimpleFunc f) a) ∂μ).toReal
state_after: no goals
Theorem: Equiv.Perm.cycleOf_apply_apply_self
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: convert cycleOf_apply_apply_pow_self f x 1 using 1
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f✝ g : Perm α
x✝ y : α
inst✝² : DecidableRel f✝.SameCycle
inst✝¹ : DecidableRel g.SameCycle
f : Perm α
inst✝ : DecidableRel f.SameCycle
x : α
⊢ (f.cycleOf x) (f x) = f (f x)
state_after: no goals