1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Batteries.RBNode.reverse_ins
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: induction t <;> [skip; (rename_i c a y b iha ihb; cases c)] <;> simp [ins, flip]
  <;> rw [← inst.symm x y] <;> split <;> simp [*, Ordering.swap, iha, ihb]
state_before: α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
t : RBNode α
⊢ (ins cmp x t).reverse = ins (flip cmp) x t.reverse
state_after: no goals

tactic: rename_i c a y b iha ihb
state_before: case node
α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : (ins cmp x l✝).reverse = ins (flip cmp) x l✝.reverse
r_ih✝ : (ins cmp x r✝).reverse = ins (flip cmp) x r✝.reverse
⊢ (ins cmp x (node c✝ l✝ v✝ r✝)).reverse = ins (flip cmp) x (node c✝ l✝ v✝ r✝).reverse
state_after: case node
α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
c : RBColor
a : RBNode α
y : α
b : RBNode α
iha : (ins cmp x a).reverse = ins (flip cmp) x a.reverse
ihb : (ins cmp x b).reverse = ins (flip cmp) x b.reverse
⊢ (ins cmp x (node c a y b)).reverse = ins (flip cmp) x (node c a y b).reverse

tactic: cases c
state_before: case node
α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
c : RBColor
a : RBNode α
y : α
b : RBNode α
iha : (ins cmp x a).reverse = ins (flip cmp) x a.reverse
ihb : (ins cmp x b).reverse = ins (flip cmp) x b.reverse
⊢ (ins cmp x (node c a y b)).reverse = ins (flip cmp) x (node c a y b).reverse
state_after: case node.red
α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
a : RBNode α
y : α
b : RBNode α
iha : (ins cmp x a).reverse = ins (flip cmp) x a.reverse
ihb : (ins cmp x b).reverse = ins (flip cmp) x b.reverse
⊢ (ins cmp x (node red a y b)).reverse = ins (flip cmp) x (node red a y b).reverse

case node.black
α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
a : RBNode α
y : α
b : RBNode α
iha : (ins cmp x a).reverse = ins (flip cmp) x a.reverse
ihb : (ins cmp x b).reverse = ins (flip cmp) x b.reverse
⊢ (ins cmp x (node black a y b)).reverse = ins (flip cmp) x (node black a y b).reverse
Theorem: toIocMod_sub'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocMod_sub_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (a - p) b = toIocMod hp a b - p
state_after: no goals
Theorem: Finset.noncommProd_induction
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: refine Multiset.noncommProd_induction _ _ _ hom unit fun b hb ↦ ?_
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
⊢ p (s.noncommProd f comm)
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ p b

tactic: obtain (⟨a, ha : a ∈ s, rfl : f a = b⟩) := by simpa using hb
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ p b
state_after: case intro.intro
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
a : α
ha : a ∈ s
hb : f a ∈ Multiset.map f s.val
⊢ p (f a)

tactic: exact base a ha
state_before: case intro.intro
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
a : α
ha : a ∈ s
hb : f a ∈ Multiset.map f s.val
⊢ p (f a)
state_after: no goals

tactic: simpa using hb
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ ?m.23727
state_after: no goals
Theorem: Finset.subset_insert_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [subset_iff, or_iff_not_imp_left, mem_erase, mem_insert, and_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ s ⊆ insert a t ↔ s.erase a ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ (∀ ⦃x : α⦄, x ∈ s → ¬x = a → x ∈ t) ↔ ∀ ⦃x : α⦄, x ≠ a → x ∈ s → x ∈ t

tactic: exact forall_congr' fun x => forall_swap
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ (∀ ⦃x : α⦄, x ∈ s → ¬x = a → x ∈ t) ↔ ∀ ⦃x : α⦄, x ≠ a → x ∈ s → x ∈ t
state_after: no goals
Theorem: Zsqrtd.intCast_dvd
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: constructor
state_before: d z : ℤ
a : ℤ√d
⊢ ↑z ∣ a ↔ z ∣ a.re ∧ z ∣ a.im
state_after: case mp
d z : ℤ
a : ℤ√d
⊢ ↑z ∣ a → z ∣ a.re ∧ z ∣ a.im

case mpr
d z : ℤ
a : ℤ√d
⊢ z ∣ a.re ∧ z ∣ a.im → ↑z ∣ a

tactic: rintro ⟨x, rfl⟩
state_before: case mp
d z : ℤ
a : ℤ√d
⊢ ↑z ∣ a → z ∣ a.re ∧ z ∣ a.im
state_after: case mp.intro
d z : ℤ
x : ℤ√d
⊢ z ∣ (↑z * x).re ∧ z ∣ (↑z * x).im

tactic: simp only [add_zero, intCast_re, zero_mul, mul_im, dvd_mul_right, and_self_iff,
  mul_re, mul_zero, intCast_im]
state_before: case mp.intro
d z : ℤ
x : ℤ√d
⊢ z ∣ (↑z * x).re ∧ z ∣ (↑z * x).im
state_after: no goals

tactic: rintro ⟨⟨r, hr⟩, ⟨i, hi⟩⟩
state_before: case mpr
d z : ℤ
a : ℤ√d
⊢ z ∣ a.re ∧ z ∣ a.im → ↑z ∣ a
state_after: case mpr.intro.intro.intro
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ ↑z ∣ a

tactic: use ⟨r, i⟩
state_before: case mpr.intro.intro.intro
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ ↑z ∣ a
state_after: case h
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a = ↑z * { re := r, im := i }

tactic: rw [smul_val, Zsqrtd.ext_iff]
state_before: case h
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a = ↑z * { re := r, im := i }
state_after: case h
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a.re = { re := z * r, im := z * i }.re ∧ a.im = { re := z * r, im := z * i }.im

tactic: exact ⟨hr, hi⟩
state_before: case h
d z : ℤ
a : ℤ√d
r : ℤ
hr : a.re = z * r
i : ℤ
hi : a.im = z * i
⊢ a.re = { re := z * r, im := z * i }.re ∧ a.im = { re := z * r, im := z * i }.im
state_after: no goals
Theorem: AdjoinRoot.algEquivOfAssociated_apply_root
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [← coe_algHom, algEquivOfAssociated_toAlgHom, liftHom_root]
state_before: K : Type u_1
L : Type ?u.610917
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
p q : K[X]
hp : p ≠ 0
hpq : Associated p q
⊢ (algEquivOfAssociated hp hpq) (root p) = root q
state_after: no goals
Theorem: ArithmeticFunction.IsMultiplicative.pmul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [hf, hg]
state_before: R : Type u_1
inst✝ : CommSemiring R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
⊢ (f.pmul g) 1 = 1
state_after: no goals

tactic: simp only [pmul_apply, hf.map_mul_of_coprime cop, hg.map_mul_of_coprime cop]
state_before: R : Type u_1
inst✝ : CommSemiring R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ (f.pmul g) (m * n) = (f.pmul g) m * (f.pmul g) n
state_after: R : Type u_1
inst✝ : CommSemiring R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ f m * f n * (g m * g n) = f m * g m * (f n * g n)

tactic: ring
state_before: R : Type u_1
inst✝ : CommSemiring R
f g : ArithmeticFunction R
hf : f.IsMultiplicative
hg : g.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ f m * f n * (g m * g n) = f m * g m * (f n * g n)
state_after: no goals
Theorem: Batteries.DList.toList_push
File: Mathlib/Data/DList/Defs.lean

tactic: cases' l with _ l_invariant
state_before: α : Type u
x : α
l : DList α
⊢ (l.push x).toList = l.toList ++ [x]
state_after: case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝, invariant := l_invariant }.push x).toList =
    { apply := apply✝, invariant := l_invariant }.toList ++ [x]

tactic: simp
state_before: case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ ({ apply := apply✝, invariant := l_invariant }.push x).toList =
    { apply := apply✝, invariant := l_invariant }.toList ++ [x]
state_after: case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝ [x] = apply✝ [] ++ [x]

tactic: rw [l_invariant]
state_before: case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝ [x] = apply✝ [] ++ [x]
state_after: no goals
Theorem: minpoly.natSepDegree_eq_one_iff_eq_X_pow_sub_C
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: simp only [minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C q, map_sub, expand_X, expand_C]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
x : E
⊢ (minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = X ^ q ^ n - C y
state_after: no goals
Theorem: sup_sdiff_cancel'
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_sdiff_eq_sup hab, sup_of_le_right hbc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
hab : a ≤ b
hbc : b ≤ c
⊢ b ⊔ c \ a = c
state_after: no goals
Theorem: Finset.card_add_card_compl
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [Finset.card_compl, ← Nat.add_sub_assoc (card_le_univ s), Nat.add_sub_cancel_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
⊢ s.card + sᶜ.card = Fintype.card α
state_after: no goals
Theorem: CoxeterSystem.length_eq_zero_iff
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: constructor
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w = 0 ↔ w = 1
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w = 0 → w = 1

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ w = 1 → cs.length w = 0

tactic: intro h
state_before: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w = 0 → w = 1
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
h : cs.length w = 0
⊢ w = 1

tactic: rcases cs.exists_reduced_word w with ⟨ω, hω, rfl⟩
state_before: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
h : cs.length w = 0
⊢ w = 1
state_after: case mp.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
h : cs.length (cs.wordProd ω) = 0
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.wordProd ω = 1

tactic: have : ω = [] := eq_nil_of_length_eq_zero (hω.trans h)
state_before: case mp.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
h : cs.length (cs.wordProd ω) = 0
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.wordProd ω = 1
state_after: case mp.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
h : cs.length (cs.wordProd ω) = 0
hω : ω.length = cs.length (cs.wordProd ω)
this : ω = []
⊢ cs.wordProd ω = 1

tactic: rw [this, wordProd_nil]
state_before: case mp.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
h : cs.length (cs.wordProd ω) = 0
hω : ω.length = cs.length (cs.wordProd ω)
this : ω = []
⊢ cs.wordProd ω = 1
state_after: no goals

tactic: rintro rfl
state_before: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ w = 1 → cs.length w = 0
state_after: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.length 1 = 0

tactic: exact cs.length_one
state_before: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.length 1 = 0
state_after: no goals
Theorem: Real.logb_div_base
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← inv_logb_div_base h₁ h₂ c, inv_inv]
state_before: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹
state_after: no goals
Theorem: WithTop.map_le_iff
File: Mathlib/Order/WithBot.lean

tactic: erw [← toDual_le_toDual_iff, toDual_map, toDual_map, WithBot.map_le_iff, toDual_le_toDual_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ map f a ≤ map f b ↔ a ≤ b
state_after: case mono_iff
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ ∀ {a b : αᵒᵈ}, (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) a ≤ (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) b ↔ a ≤ b

tactic: simp [mono_iff]
state_before: case mono_iff
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ ∀ {a b : αᵒᵈ}, (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) a ≤ (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) b ↔ a ≤ b
state_after: no goals
Theorem: LinearMap.IsSymmetric.invariant_orthogonalComplement_eigenspace
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

tactic: intro w hw
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
⊢ T v ∈ (eigenspace T μ)ᗮ
state_after: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
w : E
hw : w ∈ eigenspace T μ
⊢ ⟪w, T v⟫_𝕜 = 0

tactic: have : T w = (μ : 𝕜) • w := by rwa [mem_eigenspace_iff] at hw
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
w : E
hw : w ∈ eigenspace T μ
⊢ ⟪w, T v⟫_𝕜 = 0
state_after: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
w : E
hw : w ∈ eigenspace T μ
this : T w = μ • w
⊢ ⟪w, T v⟫_𝕜 = 0

tactic: simp [← hT w, this, inner_smul_left, hv w hw]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
w : E
hw : w ∈ eigenspace T μ
this : T w = μ • w
⊢ ⟪w, T v⟫_𝕜 = 0
state_after: no goals

tactic: rwa [mem_eigenspace_iff] at hw
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
v : E
hv : v ∈ (eigenspace T μ)ᗮ
w : E
hw : w ∈ eigenspace T μ
⊢ T w = μ • w
state_after: no goals
Theorem: NormedField.continuousAt_zpow
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine ⟨?_, continuousAt_zpow₀ _ _⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
x : 𝕜
⊢ ContinuousAt (fun x => x ^ m) x ↔ x ≠ 0 ∨ 0 ≤ m
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
x : 𝕜
⊢ ContinuousAt (fun x => x ^ m) x → x ≠ 0 ∨ 0 ≤ m

tactic: contrapose!
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
x : 𝕜
⊢ ContinuousAt (fun x => x ^ m) x → x ≠ 0 ∨ 0 ≤ m
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
x : 𝕜
⊢ x = 0 ∧ m < 0 → ¬ContinuousAt (fun x => x ^ m) x

tactic: rintro ⟨rfl, hm⟩ hc
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
x : 𝕜
⊢ x = 0 ∧ m < 0 → ¬ContinuousAt (fun x => x ^ m) x
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
hm : m < 0
hc : ContinuousAt (fun x => x ^ m) 0
⊢ False

tactic: exact not_tendsto_atTop_of_tendsto_nhds (hc.tendsto.mono_left nhdsWithin_le_nhds).norm
  (tendsto_norm_zpow_nhdsWithin_0_atTop hm)
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
m : ℤ
hm : m < 0
hc : ContinuousAt (fun x => x ^ m) 0
⊢ False
state_after: no goals
Theorem: measure_le_lintegral_thickenedIndicatorAux
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
state_before: X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ μ E ≤ ∫⁻ (x : X), thickenedIndicatorAux δ E x ∂μ
state_after: case h.e'_3
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ μ E = lintegral μ (E.indicator fun x => 1)

X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ lintegral μ (E.indicator fun x => 1) ≤ lintegral μ (thickenedIndicatorAux δ E)

tactic: rw [lintegral_indicator _ E_mble]
state_before: case h.e'_3
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ μ E = lintegral μ (E.indicator fun x => 1)
state_after: case h.e'_3
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ μ E = ∫⁻ (a : X) in E, 1 ∂μ

tactic: simp only [lintegral_one, Measure.restrict_apply, MeasurableSet.univ, univ_inter]
state_before: case h.e'_3
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ μ E = ∫⁻ (a : X) in E, 1 ∂μ
state_after: no goals

tactic: apply lintegral_mono
state_before: X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ lintegral μ (E.indicator fun x => 1) ≤ lintegral μ (thickenedIndicatorAux δ E)
state_after: case hfg
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ (E.indicator fun x => 1) ≤ thickenedIndicatorAux δ E

tactic: apply indicator_le_thickenedIndicatorAux
state_before: case hfg
X : Type u_1
Y : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace X
inst✝ : PseudoEMetricSpace X
μ : Measure X
E : Set X
E_mble : MeasurableSet E
δ : ℝ
⊢ (E.indicator fun x => 1) ≤ thickenedIndicatorAux δ E
state_after: no goals
Theorem: Ideal.IsDedekindDomain.ramificationIdx_eq_factors_count
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rw [IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count hp0 hP hP0,
  factors_eq_normalizedFactors]
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : P.IsPrime
hP0 : P ≠ ⊥
⊢ ramificationIdx f p P = Multiset.count P (factors (map f p))
state_after: no goals
Theorem: List.eraseP_append_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [(forall_mem_cons.1 h).1, eraseP_append_right _ (forall_mem_cons.1 h).2]
state_before: α : Type u_1
p : α → Bool
x : α
xs l₂ : List α
h : ∀ (b : α), b ∈ x :: xs → ¬p b = true
⊢ eraseP p (x :: xs ++ l₂) = x :: xs ++ eraseP p l₂
state_after: no goals
Theorem: PiTensorProduct.piTensorHomMap_tprod_tprod
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

tactic: simp [piTensorHomMap]
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝¹¹ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝¹⁰ : (i : ι) → AddCommMonoid (s i)
inst✝⁹ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
E : Type u_9
inst✝⁶ : AddCommMonoid E
inst✝⁵ : Module R E
F : Type u_10
inst✝⁴ : AddCommMonoid F
t : ι → Type u_11
t' : ι → Type u_12
inst✝³ : (i : ι) → AddCommMonoid (t i)
inst✝² : (i : ι) → Module R (t i)
inst✝¹ : (i : ι) → AddCommMonoid (t' i)
inst✝ : (i : ι) → Module R (t' i)
g : (i : ι) → t i →ₗ[R] t' i
f✝ f : (i : ι) → s i →ₗ[R] t i
x : (i : ι) → s i
⊢ (piTensorHomMap ((tprod R) f)) ((tprod R) x) = ⨂ₜ[R] (i : ι), (f i) (x i)
state_after: no goals
Theorem: Filter.not_tendsto_iff_exists_frequently_nmem
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [tendsto_iff_forall_eventually_mem, not_forall, exists_prop, not_eventually]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : α → β
l₁ : Filter α
l₂ : Filter β
⊢ ¬Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ (x : α) in l₁, f x ∉ s
state_after: no goals
Theorem: Isometry.ediam_image
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [EMetric.diam_le_iff, forall_mem_image, hf.edist_eq]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x y z : α
s✝ : Set α
hf : Isometry f
s : Set α
d : ℝ≥0∞
⊢ EMetric.diam (f '' s) ≤ d ↔ EMetric.diam s ≤ d
state_after: no goals
Theorem: Finset.max_of_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain ⟨b, h, _⟩ := le_sup (α := WithBot α) h _ rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h : a ∈ s
⊢ ∃ b, s.max = ↑b
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.sup WithBot.some = ↑b
right✝ : a ≤ b
⊢ ∃ b, s.max = ↑b

tactic: exact ⟨b, h⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : s.sup WithBot.some = ↑b
right✝ : a ≤ b
⊢ ∃ b, s.max = ↑b
state_after: no goals
Theorem: MeasureTheory.snorm_eq_lintegral_rpow_nnnorm
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [snorm_eq_snorm' hp_ne_zero hp_ne_top, snorm']
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
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
⊢ snorm f p μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)
state_after: no goals