1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.isRoot_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simp_rw [IsRoot, eval_comp]
state_before: R✝ : Type u
S : Type v
T : Type w
ι : Type y
a b : R✝
m n : ℕ
inst✝² : CommSemiring R✝
p✝ q✝ : R✝[X]
x : R✝
inst✝¹ : CommSemiring S
f : R✝ →+* S
R : Type u_1
inst✝ : CommSemiring R
p q : R[X]
r : R
⊢ (p.comp q).IsRoot r ↔ p.IsRoot (eval r q)
state_after: no goals
Theorem: Nat.factorial_inj'
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: obtain hn|hm := h
state_before: m n : ℕ
h : 1 < n ∨ 1 < m
⊢ n ! = m ! ↔ n = m
state_after: case inl
m n : ℕ
hn : 1 < n
⊢ n ! = m ! ↔ n = m

case inr
m n : ℕ
hm : 1 < m
⊢ n ! = m ! ↔ n = m

tactic: exact factorial_inj hn
state_before: case inl
m n : ℕ
hn : 1 < n
⊢ n ! = m ! ↔ n = m
state_after: no goals

tactic: rw [eq_comm, factorial_inj hm, eq_comm]
state_before: case inr
m n : ℕ
hm : 1 < m
⊢ n ! = m ! ↔ n = m
state_after: no goals
Theorem: CategoryTheory.NatIso.naturality_1
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y : C
α : F ≅ G
f : X ⟶ Y
⊢ α.inv.app X ≫ F.map f ≫ α.hom.app Y = G.map f
state_after: no goals
Theorem: PMF.toMeasure_apply_singleton
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: simp [toMeasure_apply_eq_toOuterMeasure_apply _ _ h, toOuterMeasure_apply_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : MeasurableSpace α
p : PMF α
s t : Set α
a : α
h : MeasurableSet {a}
⊢ p.toMeasure {a} = p a
state_after: no goals
Theorem: ContinuousLinearMap.iInf_rayleigh_eq_iInf_rayleigh_sphere
File: Mathlib/Analysis/InnerProductSpace/Rayleigh.lean

tactic: simp only [← @sInf_image' _ _ _ _ (rayleighQuotient T),
  T.image_rayleigh_eq_image_rayleigh_sphere hr]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →L[𝕜] E
r : ℝ
hr : 0 < r
⊢ ⨅ x, T.rayleighQuotient ↑x = ⨅ x, T.rayleighQuotient ↑x
state_after: no goals
Theorem: DiscreteValuationRing.addVal_uniformizer
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: simpa only [one_mul, eq_self_iff_true, Units.val_one, pow_one, forall_true_left, Nat.cast_one]
  using addVal_def ϖ 1 hϖ 1
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
ϖ : R
hϖ : Irreducible ϖ
⊢ (addVal R) ϖ = 1
state_after: no goals
Theorem: Nat.ofDigits_div_eq_ofDigits_tail
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' digits with hd tl
state_before: n p : ℕ
hpos : 0 < p
digits : List ℕ
w₁ : ∀ l ∈ digits, l < p
⊢ ofDigits p digits / p = ofDigits p digits.tail
state_after: case nil
n p : ℕ
hpos : 0 < p
w₁ : ∀ l ∈ [], l < p
⊢ ofDigits p [] / p = ofDigits p [].tail

case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ ofDigits p (hd :: tl) / p = ofDigits p (hd :: tl).tail

tactic: simp [ofDigits]
state_before: case nil
n p : ℕ
hpos : 0 < p
w₁ : ∀ l ∈ [], l < p
⊢ ofDigits p [] / p = ofDigits p [].tail
state_after: no goals

tactic: refine Eq.trans (add_mul_div_left hd _ hpos) ?_
state_before: case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ ofDigits p (hd :: tl) / p = ofDigits p (hd :: tl).tail
state_after: case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ hd / p + ofDigits p tl = ofDigits p (hd :: tl).tail

tactic: rw [Nat.div_eq_of_lt <| w₁ _ <| List.mem_cons_self _ _, zero_add]
state_before: case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ hd / p + ofDigits p tl = ofDigits p (hd :: tl).tail
state_after: case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ ofDigits p tl = ofDigits p (hd :: tl).tail

tactic: rfl
state_before: case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ ofDigits p tl = ofDigits p (hd :: tl).tail
state_after: no goals
Theorem: Cauchy.prod
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: have := hf.1
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : UniformSpace β
f : Filter α
g : Filter β
hf : Cauchy f
hg : Cauchy g
⊢ Cauchy (f ×ˢ g)
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : UniformSpace β
f : Filter α
g : Filter β
hf : Cauchy f
hg : Cauchy g
this : f.NeBot
⊢ Cauchy (f ×ˢ g)

tactic: have := hg.1
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : UniformSpace β
f : Filter α
g : Filter β
hf : Cauchy f
hg : Cauchy g
this : f.NeBot
⊢ Cauchy (f ×ˢ g)
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : UniformSpace β
f : Filter α
g : Filter β
hf : Cauchy f
hg : Cauchy g
this✝ : f.NeBot
this : g.NeBot
⊢ Cauchy (f ×ˢ g)

tactic: simpa [cauchy_prod_iff, hf.1] using ⟨hf, hg⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : UniformSpace β
f : Filter α
g : Filter β
hf : Cauchy f
hg : Cauchy g
this✝ : f.NeBot
this : g.NeBot
⊢ Cauchy (f ×ˢ g)
state_after: no goals
Theorem: ZMod.intCast_mod
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [ZMod.intCast_eq_intCast_iff]
state_before: a : ℤ
b : ℕ
⊢ ↑(a % ↑b) = ↑a
state_after: a : ℤ
b : ℕ
⊢ a % ↑b ≡ a [ZMOD ↑b]

tactic: apply Int.mod_modEq
state_before: a : ℤ
b : ℕ
⊢ a % ↑b ≡ a [ZMOD ↑b]
state_after: no goals
Theorem: closure_eq_inter_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp only [compRel_assoc]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
t : Set (α × α)
⊢ ⋂ V ∈ 𝓤 α, V ○ t ○ V = ⋂ V ∈ 𝓤 α, V ○ (t ○ V)
state_after: no goals
Theorem: mem_convexHull_iff
File: Mathlib/Analysis/Convex/Hull.lean

tactic: simp_rw [convexHull_eq_iInter, mem_iInter]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x y : E
⊢ x ∈ (convexHull 𝕜) s ↔ ∀ (t : Set E), s ⊆ t → Convex 𝕜 t → x ∈ t
state_after: no goals
Theorem: IsSubfield.div_mem
File: Mathlib/Deprecated/Subfield.lean

tactic: rw [div_eq_mul_inv]
state_before: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x / y ∈ S
state_after: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x * y⁻¹ ∈ S

tactic: exact hS.toIsSubring.toIsSubmonoid.mul_mem hx (hS.inv_mem hy)
state_before: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x * y⁻¹ ∈ S
state_after: no goals
Theorem: ofDual_compares_ofDual
File: Mathlib/Order/Compare.lean

tactic: cases o
state_before: α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
o : Ordering
⊢ o.Compares (ofDual a) (ofDual b) ↔ o.Compares b a
state_after: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ lt.Compares (ofDual a) (ofDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ eq.Compares (ofDual a) (ofDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ gt.Compares (ofDual a) (ofDual b) ↔ gt.Compares b a

tactic: exacts [Iff.rfl, eq_comm, Iff.rfl]
state_before: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ lt.Compares (ofDual a) (ofDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ eq.Compares (ofDual a) (ofDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : αᵒᵈ
⊢ gt.Compares (ofDual a) (ofDual b) ↔ gt.Compares b a
state_after: no goals
Theorem: Module.AEval.comapSubmodule_mapSubmodule
File: Mathlib/Algebra/Polynomial/Module/AEval.lean

tactic: ext
state_before: R : Type u_2
A : Type u_3
M : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
a : A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
p : Submodule R M
hp : p ≤ Submodule.comap ((Algebra.lsmul R R M) a) p
q : Submodule R[X] (AEval R M a)
⊢ (comapSubmodule R M a) (mapSubmodule a hp) = p
state_after: case h
R : Type u_2
A : Type u_3
M : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
a : A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
p : Submodule R M
hp : p ≤ Submodule.comap ((Algebra.lsmul R R M) a) p
q : Submodule R[X] (AEval R M a)
x✝ : M
⊢ x✝ ∈ (comapSubmodule R M a) (mapSubmodule a hp) ↔ x✝ ∈ p

tactic: simp
state_before: case h
R : Type u_2
A : Type u_3
M : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
a : A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
p : Submodule R M
hp : p ≤ Submodule.comap ((Algebra.lsmul R R M) a) p
q : Submodule R[X] (AEval R M a)
x✝ : M
⊢ x✝ ∈ (comapSubmodule R M a) (mapSubmodule a hp) ↔ x✝ ∈ p
state_after: no goals
Theorem: Int.mul_dvd_of_dvd_div
File: Mathlib/Data/Int/Defs.lean

tactic: simpa [Int.mul_comm, Int.mul_left_comm] using Int.eq_mul_of_ediv_eq_left hcb hd
state_before: a b c d✝ m n : ℤ
hcb : c ∣ b
h : a ∣ b / c
d : ℤ
hd : b / c = a * d
⊢ b = c * a * d
state_after: no goals
Theorem: Turing.ListBlank.nth_map
File: Mathlib/Computability/TuringMachine.lean

tactic: refine l.inductionOn fun l ↦ ?_
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
n : ℕ
⊢ (map f l).nth n = f.f (l.nth n)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (map f ⟦l⟧).nth n = f.f (nth ⟦l⟧ n)

tactic: suffices ((mk l).map f).nth n = f ((mk l).nth n) by exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (map f ⟦l⟧).nth n = f.f (nth ⟦l⟧ n)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (map f (mk l)).nth n = f.f ((mk l).nth n)

tactic: simp only [List.get?_map, ListBlank.map_mk, ListBlank.nth_mk, List.getI_eq_iget_get?]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (map f (mk l)).nth n = f.f ((mk l).nth n)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (Option.map f.f (l.get? n)).iget = f.f (l.get? n).iget

tactic: cases l.get? n
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (Option.map f.f (l.get? n)).iget = f.f (l.get? n).iget
state_after: case none
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (Option.map f.f none).iget = f.f none.iget

case some
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
val✝ : Γ
⊢ (Option.map f.f (some val✝)).iget = f.f (some val✝).iget

tactic: exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
this : (map f (mk l)).nth n = f.f ((mk l).nth n)
⊢ (map f ⟦l⟧).nth n = f.f (nth ⟦l⟧ n)
state_after: no goals

tactic: exact f.2.symm
state_before: case none
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
⊢ (Option.map f.f none).iget = f.f none.iget
state_after: no goals

tactic: rfl
state_before: case some
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l✝ : ListBlank Γ
n : ℕ
l : List Γ
val✝ : Γ
⊢ (Option.map f.f (some val✝)).iget = f.f (some val✝).iget
state_after: no goals
Theorem: CategoryTheory.MonoidalFunctor.mapAction_μ_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: rw [← cancel_mono (F.μ X.V Y.V), IsIso.inv_hom_id, ← F.mapAction_toLaxMonoidalFunctor_μ_hom G,
  ← Action.comp_hom, IsIso.inv_hom_id, Action.id_hom]
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y : Action V G
⊢ (inv ((F.mapAction G).μ X Y)).hom = inv (F.μ X.V Y.V)
state_after: no goals
Theorem: Finset.filter_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ : Finset α
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ filter p (s.erase a) = (filter p s).erase a
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ : Finset α
inst✝ : DecidableEq α
a : α
s : Finset α
x : α
⊢ x ∈ filter p (s.erase a) ↔ x ∈ (filter p s).erase a

tactic: simp only [and_assoc, mem_filter, iff_self_iff, mem_erase]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ : Finset α
inst✝ : DecidableEq α
a : α
s : Finset α
x : α
⊢ x ∈ filter p (s.erase a) ↔ x ∈ (filter p s).erase a
state_after: no goals
Theorem: List.rotate_nil
File: Mathlib/Data/List/Rotate.lean

tactic: simp [rotate]
state_before: α : Type u
n : ℕ
⊢ [].rotate n = []
state_after: no goals
Theorem: dist_self_div_right
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: rw [div_eq_mul_inv, dist_self_mul_right, norm_inv']
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a (a / b) = ‖b‖
state_after: no goals
Theorem: orderOf_pos_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [iff_not_comm.mp orderOf_eq_zero_iff, pos_iff_ne_zero]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ 0 < orderOf x ↔ IsOfFinOrder x
state_after: no goals
Theorem: Denumerable.prod_ofNat_val
File: Mathlib/Logic/Denumerable.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
n : ℕ
⊢ ofNat (α × β) n = (ofNat α (unpair n).1, ofNat β (unpair n).2)
state_after: no goals
Theorem: MeasureTheory.snorm_eq_zero_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: by_cases h_top : p = ∞
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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
⊢ snorm f p μ = 0 ↔ f =ᶠ[ae μ] 0
state_after: case pos
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᶠ[ae μ] 0

case neg
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᶠ[ae μ] 0

tactic: rw [snorm_eq_snorm' h0 h_top]
state_before: case neg
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᶠ[ae μ] 0
state_after: case neg
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm' f p.toReal μ = 0 ↔ f =ᶠ[ae μ] 0

tactic: exact snorm'_eq_zero_iff (ENNReal.toReal_pos h0 h_top) hf
state_before: case neg
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm' f p.toReal μ = 0 ↔ f =ᶠ[ae μ] 0
state_after: no goals

tactic: rw [h_top, snorm_exponent_top, snormEssSup_eq_zero_iff]
state_before: case pos
α : 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
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᶠ[ae μ] 0
state_after: no goals
Theorem: Matrix.IsHermitian.rank_eq_card_non_zero_eigs
File: Mathlib/LinearAlgebra/Matrix/Spectrum.lean

tactic: rw [rank_eq_rank_diagonal hA, Matrix.rank_diagonal]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
n : Type u_2
inst✝¹ : Fintype n
A : Matrix n n 𝕜
inst✝ : DecidableEq n
hA : A.IsHermitian
⊢ A.rank = Fintype.card { i // hA.eigenvalues i ≠ 0 }
state_after: no goals
Theorem: Subgroup.top_prod
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_snd]
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
H✝ K : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup N
x : G × N
⊢ x ∈ ⊤.prod H ↔ x ∈ comap (MonoidHom.snd G N) H
state_after: no goals
Theorem: Module.Finite.exists_fin'
File: Mathlib/RingTheory/Finiteness.lean

tactic: have ⟨n, s, hs⟩ := exists_fin (R := R) (M := M)
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : Finite R M
⊢ ∃ n f, Surjective ⇑f
state_after: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : Finite R M
n : ℕ
s : Fin n → M
hs : span R (range s) = ⊤
⊢ ∃ n f, Surjective ⇑f

tactic: refine ⟨n, Basis.constr (Pi.basisFun R _) ℕ s, ?_⟩
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : Finite R M
n : ℕ
s : Fin n → M
hs : span R (range s) = ⊤
⊢ ∃ n f, Surjective ⇑f
state_after: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : Finite R M
n : ℕ
s : Fin n → M
hs : span R (range s) = ⊤
⊢ Surjective ⇑(((Pi.basisFun R (Fin n)).constr ℕ) s)

tactic: rw [← LinearMap.range_eq_top, Basis.constr_range, hs]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
inst✝ : Finite R M
n : ℕ
s : Fin n → M
hs : span R (range s) = ⊤
⊢ Surjective ⇑(((Pi.basisFun R (Fin n)).constr ℕ) s)
state_after: no goals
Theorem: List.countP_cons_of_neg
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: simp [countP, countP.go, pa]
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : ¬p a = true
⊢ countP p (a :: l) = countP p l
state_after: no goals
Theorem: Vector.insertNth_comm
File: Mathlib/Data/Vector/Basic.lean

tactic: refine Subtype.eq ?_
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ insertNth b j.succ (insertNth a i ⟨l, hl⟩) = insertNth a i.castSucc (insertNth b j ⟨l, hl⟩)
state_after: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑(insertNth b j.succ (insertNth a i ⟨l, hl⟩)) = ↑(insertNth a i.castSucc (insertNth b j ⟨l, hl⟩))

tactic: simp only [insertNth_val, Fin.val_succ, Fin.castSucc, Fin.coe_castAdd]
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑(insertNth b j.succ (insertNth a i ⟨l, hl⟩)) = ↑(insertNth a i.castSucc (insertNth b j ⟨l, hl⟩))
state_after: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ List.insertNth (↑j + 1) b (List.insertNth (↑i) a l) = List.insertNth (↑i) a (List.insertNth (↑j) b l)

tactic: apply List.insertNth_comm
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ List.insertNth (↑j + 1) b (List.insertNth (↑i) a l) = List.insertNth (↑i) a (List.insertNth (↑j) b l)
state_after: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑i ≤ ↑j

case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑j ≤ l.length

tactic: assumption
state_before: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑i ≤ ↑j
state_after: no goals

tactic: rw [hl]
state_before: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑j ≤ l.length
state_after: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑j ≤ n

tactic: exact Nat.le_of_succ_le_succ j.2
state_before: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑j ≤ n
state_after: no goals