1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MonoidAlgebra.lift_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [lift_def, liftNC_single, Algebra.smul_def, AddMonoidHom.coe_coe]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁶ : CommSemiring k
inst✝⁵ : Monoid G
inst✝⁴ : Monoid H
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
a : G
b : k
⊢ ((lift k G A) F) (single a b) = b • F a
state_after: no goals
Theorem: CategoryTheory.NatIso.cancel_natIso_hom_right_assoc
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [← Category.assoc, cancel_mono, refl]
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
α : F ≅ G
W X X' : D
Y : C
f : W ⟶ X
g : X ⟶ F.obj Y
f' : W ⟶ X'
g' : X' ⟶ F.obj Y
⊢ f ≫ g ≫ α.hom.app Y = f' ≫ g' ≫ α.hom.app Y ↔ f ≫ g = f' ≫ g'
state_after: no goals
Theorem: List.sublists'Aux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

tactic: intro r₁ r₂
state_before: α : Type u
β : Type v
γ : Type w
a : α
⊢ ∀ (r₁ r₂ : List (List α)),
    sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList

tactic: rw [sublists'Aux, Array.foldl_eq_foldl_data]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList

tactic: have := List.foldl_hom Array.toList (fun r l => r.push (a :: l))
  (fun r l => r ++ [a :: l]) r₁ r₂.toArray (by simp)
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
this :
  foldl (fun r l => r ++ [a :: l]) (toArray r₂).toList r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) r₁).toList
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList

tactic: simpa using this
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
this :
  foldl (fun r l => r ++ [a :: l]) (toArray r₂).toList r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) r₁).toList
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ ∀ (x : Array (List α)) (y : List α), (fun r l => r ++ [a :: l]) x.toList y = ((fun r l => r.push (a :: l)) x y).toList
state_after: no goals
Theorem: Equiv.traverse_eq_map_id
File: Mathlib/Control/Traversable/Equiv.lean

tactic: simp only [Equiv.traverse, traverse_eq_map_id, Id.map_eq, Id.pure_eq]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ Equiv.traverse eqv (pure ∘ f) x = pure (Equiv.map eqv f x)
state_after: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ (eqv β) (id.mk (f <$> (eqv α).symm x)) = Equiv.map eqv f x

tactic: rfl
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ (eqv β) (id.mk (f <$> (eqv α).symm x)) = Equiv.map eqv f x
state_after: no goals
Theorem: QuotientAddGroup.norm_eq_infDist
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: simp only [AddSubgroup.quotient_norm_eq, infDist_eq_iInf, sInf_image', dist_zero_left]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ ‖x‖ = infDist 0 {m | ↑m = x}
state_after: no goals
Theorem: ProbabilityTheory.iIndepSets.meas_iInter
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp [← h.meas_biInter _ fun _i _ ↦ hs _]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ : Measure Ω
S : Finset ι
s : ι → Set Ω
inst✝ : Fintype ι
h : iIndepSets π μ
hs : ∀ (i : ι), s i ∈ π i
⊢ μ (⋂ i, s i) = ∏ i : ι, μ (s i)
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.realSize_tail
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ (tail le s).realSize = s.realSize - 1
state_after: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ ((tail? le s).getD nil).realSize = s.realSize - 1

tactic: match eq : s.tail? le with
| none => cases s with cases eq | nil => rfl
| some tl => simp [Heap.realSize_tail? eq]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ ((tail? le s).getD nil).realSize = s.realSize - 1
state_after: no goals

tactic: cases s with cases eq | nil => rfl
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
eq : tail? le s = none
⊢ (none.getD nil).realSize = s.realSize - 1
state_after: no goals

tactic: rfl
state_before: case nil.refl
α : Type u_1
le : α → α → Bool
⊢ (none.getD nil).realSize = nil.realSize - 1
state_after: no goals

tactic: simp [Heap.realSize_tail? eq]
state_before: α : Type u_1
le : α → α → Bool
s tl : Heap α
eq : tail? le s = some tl
⊢ ((some tl).getD nil).realSize = s.realSize - 1
state_after: no goals
Theorem: map_comp_div'
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (a : G), f a⁻¹ = (f a)⁻¹
g h : ι → G
⊢ ⇑f ∘ (g / h) = ⇑f ∘ g / ⇑f ∘ h
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (a : G), f a⁻¹ = (f a)⁻¹
g h : ι → G
x✝ : ι
⊢ (⇑f ∘ (g / h)) x✝ = (⇑f ∘ g / ⇑f ∘ h) x✝

tactic: simp [map_div' f hf]
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (a : G), f a⁻¹ = (f a)⁻¹
g h : ι → G
x✝ : ι
⊢ (⇑f ∘ (g / h)) x✝ = (⇑f ∘ g / ⇑f ∘ h) x✝
state_after: no goals
Theorem: mul_dvd_mul_left
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: obtain ⟨d, rfl⟩ := h
state_before: α : Type u_1
inst✝ : Monoid α
a✝ b c : α
m n : ℕ
a : α
h : b ∣ c
⊢ a * b ∣ a * c
state_after: case intro
α : Type u_1
inst✝ : Monoid α
a✝ b : α
m n : ℕ
a d : α
⊢ a * b ∣ a * (b * d)

tactic: use d
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a✝ b : α
m n : ℕ
a d : α
⊢ a * b ∣ a * (b * d)
state_after: case h
α : Type u_1
inst✝ : Monoid α
a✝ b : α
m n : ℕ
a d : α
⊢ a * (b * d) = a * b * d

tactic: rw [mul_assoc]
state_before: case h
α : Type u_1
inst✝ : Monoid α
a✝ b : α
m n : ℕ
a d : α
⊢ a * (b * d) = a * b * d
state_after: no goals
Theorem: CategoryTheory.Reflective.comparison_full
File: Mathlib/CategoryTheory/Monad/Adjunction.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L✝ : C ⥤ D
R : D ⥤ C
inst✝ : R.Full
L : C ⥤ D
adj : L ⊣ R
X✝ Y✝ : D
f : (Monad.comparison adj).obj X✝ ⟶ (Monad.comparison adj).obj Y✝
⊢ (Monad.comparison adj).map (R.preimage f.f) = f
state_after: no goals
Theorem: Matrix.rank_mul_eq_left_of_isUnit_det
File: Mathlib/Data/Matrix/Rank.lean

tactic: suffices Function.Surjective A.mulVecLin by
  rw [rank, mulVecLin_mul, LinearMap.range_comp_of_range_eq_top _
    (LinearMap.range_eq_top.mpr this), ← rank]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
⊢ (B * A).rank = B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
⊢ Function.Surjective ⇑A.mulVecLin

tactic: intro v
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
⊢ Function.Surjective ⇑A.mulVecLin
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
v : n → R
⊢ ∃ a, A.mulVecLin a = v

tactic: exact ⟨(A⁻¹).mulVecLin v, by simp [mul_nonsing_inv _ hA]⟩
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
v : n → R
⊢ ∃ a, A.mulVecLin a = v
state_after: no goals

tactic: rw [rank, mulVecLin_mul, LinearMap.range_comp_of_range_eq_top _
  (LinearMap.range_eq_top.mpr this), ← rank]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
this : Function.Surjective ⇑A.mulVecLin
⊢ (B * A).rank = B.rank
state_after: no goals

tactic: simp [mul_nonsing_inv _ hA]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : DecidableEq n
A : Matrix n n R
B : Matrix m n R
hA : IsUnit A.det
v : n → R
⊢ A.mulVecLin (A⁻¹.mulVecLin v) = v
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.homMk₂_app_two
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{?u.205389, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 2
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
⊢ 2 < 2 + 1
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap_germ
File: Mathlib/Geometry/RingedSpace/Stalks.lean

tactic: rw [stalkMap, stalkFunctor_map_germ_assoc, stalkPushforward_germ]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
U : Opens ↑↑Y
x : ↥((Opens.map α.base).obj U)
⊢ Y.presheaf.germ ⟨α.base ↑x, ⋯⟩ ≫ stalkMap α ↑x = α.c.app { unop := U } ≫ X.presheaf.germ x
state_after: no goals
Theorem: Multiset.add_eq_union_iff_disjoint
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp_rw [← inter_eq_zero_iff_disjoint, ext, count_add, count_union, count_inter, count_zero,
  Nat.min_eq_zero_iff, Nat.add_eq_max_iff]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
⊢ s + t = s ∪ t ↔ s.Disjoint t
state_after: no goals
Theorem: Polynomial.degree_linear_lt_degree_C_mul_X_sq
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simpa only [degree_C_mul_X_pow 2 ha] using degree_linear_lt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C b * X + C c).degree < (C a * X ^ 2).degree
state_after: no goals
Theorem: CategoryTheory.sheafifyMap_id
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: simp [sheafifyMap, sheafify]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P : Cᵒᵖ ⥤ D
⊢ sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P)
state_after: no goals
Theorem: ContinuousMap.Homotopy.apply_zero_path
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/InducedMaps.lean

tactic: apply @eq_path_of_eq_image _ _ _ _ H.uliftMap _ _ _ _ _ ((Path.refl (ULift.up _)).prod p')
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ (π.map f).map ⟦p'⟧ = hcast ⋯ ≫ (π.map H.uliftMap).map (prodToProdTopI (𝟙 (fromTop { down := 0 })) ⟦p'⟧) ≫ hcast ⋯
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap (((Path.refl { down := 0 }).prod p') t)

tactic: erw [Path.prod_coe]
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap (((Path.refl { down := 0 }).prod p') t)
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap ((fun t => ((Path.refl { down := 0 }) t, p' t)) t)

tactic: simp_rw [ulift_apply]
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap ((fun t => ((Path.refl { down := 0 }) t, p' t)) t)
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H (((Path.refl { down := 0 }) t).down, p' t)

tactic: simp
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H (((Path.refl { down := 0 }) t).down, p' t)
state_after: no goals
Theorem: IsUnifLocDoublingMeasure.eventually_measure_le_scaling_constant_mul
File: Mathlib/MeasureTheory/Measure/Doubling.lean

tactic: filter_upwards [Classical.choose_spec
    (exists_eventually_forall_measure_closedBall_le_mul μ K)] with r hr x
state_before: α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
⊢ ∀ᶠ (r : ℝ) in 𝓝[>] 0, ∀ (x : α), μ (closedBall x (K * r)) ≤ ↑(scalingConstantOf μ K) * μ (closedBall x r)
state_after: case h
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K r : ℝ
hr : ∀ (x : α), ∀ t ≤ K, μ (closedBall x (t * r)) ≤ ↑(Classical.choose ⋯) * μ (closedBall x r)
x : α
⊢ μ (closedBall x (K * r)) ≤ ↑(scalingConstantOf μ K) * μ (closedBall x r)

tactic: exact (hr x K le_rfl).trans (mul_le_mul_right' (ENNReal.coe_le_coe.2 (le_max_left _ _)) _)
state_before: case h
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K r : ℝ
hr : ∀ (x : α), ∀ t ≤ K, μ (closedBall x (t * r)) ≤ ↑(Classical.choose ⋯) * μ (closedBall x r)
x : α
⊢ μ (closedBall x (K * r)) ≤ ↑(scalingConstantOf μ K) * μ (closedBall x r)
state_after: no goals
Theorem: orthogonalProjection_bot
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: ext
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
⊢ orthogonalProjection ⊥ = 0
state_after: no goals
Theorem: SimpleGraph.incMatrix_apply_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: simp only [incMatrix_apply, Set.indicator_apply_eq_zero, Pi.one_apply, one_ne_zero]
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
⊢ incMatrix R G a e = 0 ↔ e ∉ G.incidenceSet a
state_after: no goals
Theorem: SimpleGraph.deleteEdges_eq_self
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [deleteEdges, sdiff_eq_left, disjoint_fromEdgeSet]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s s₁ s₂ : Set (Sym2 V)
⊢ G.deleteEdges s = G ↔ Disjoint G.edgeSet s
state_after: no goals
Theorem: SimpleGraph.edgeSet_eq_empty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [← edgeSet_bot, edgeSet_inj]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
⊢ G.edgeSet = ∅ ↔ G = ⊥
state_after: no goals
Theorem: Algebra.mul_sub_algebraMap_commutes
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [mul_sub, ← commutes, sub_mul]
state_before: R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
x : A
r : R
⊢ x * (x - (algebraMap R A) r) = (x - (algebraMap R A) r) * x
state_after: no goals
Theorem: Real.ediam_Ioo
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rcases le_or_lt b a with (h | h)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : b ≤ a
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a < b
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)

tactic: simp [h]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : b ≤ a
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)
state_after: no goals

tactic: rw [Real.ediam_eq (isBounded_Ioo _ _), csSup_Ioo h, csInf_Ioo h]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a < b
⊢ EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a)
state_after: no goals
Theorem: Wbtw.sameRay_vsub_left
File: Mathlib/Analysis/Convex/Between.lean

tactic: rcases h with ⟨t, ⟨ht0, _⟩, rfl⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
h : Wbtw R x y z
⊢ SameRay R (y -ᵥ x) (z -ᵥ x)
state_after: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
ht0 : 0 ≤ t
right✝ : t ≤ 1
⊢ SameRay R ((lineMap x z) t -ᵥ x) (z -ᵥ x)

tactic: simpa [lineMap_apply] using SameRay.sameRay_nonneg_smul_left (z -ᵥ x) ht0
state_before: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
ht0 : 0 ≤ t
right✝ : t ≤ 1
⊢ SameRay R ((lineMap x z) t -ᵥ x) (z -ᵥ x)
state_after: no goals
Theorem: Finsupp.mem_splitSupport_iff_nonzero
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [splitSupport, @mem_image _ _ (Classical.decEq _), Ne, ← support_eq_empty, ← Ne, ←
  Finset.nonempty_iff_ne_empty, split, comapDomain, Finset.Nonempty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ i ∈ l.splitSupport ↔ l.split i ≠ 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ (∃ a ∈ l.support, a.fst = i) ↔
    ∃ x,
      x ∈ { support := l.support.preimage (Sigma.mk i) ⋯, toFun := fun a => l ⟨i, a⟩, mem_support_toFun := ⋯ }.support

tactic: simp only [exists_prop, Finset.mem_preimage, exists_and_right, exists_eq_right, mem_support_iff,
  Sigma.exists, Ne]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ (∃ a ∈ l.support, a.fst = i) ↔
    ∃ x,
      x ∈ { support := l.support.preimage (Sigma.mk i) ⋯, toFun := fun a => l ⟨i, a⟩, mem_support_toFun := ⋯ }.support
state_after: no goals
Theorem: Substring.Valid.atEnd
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [h.atEnd, h.toString]
state_before: p : Nat
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ x✝.atEnd { byteIdx := p } = true ↔ p = x✝.toString.utf8ByteSize
state_after: no goals
Theorem: Finset.piecewise_eq_of_mem
File: Mathlib/Data/Finset/Piecewise.lean

tactic: simp [piecewise, hi]
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝ : (j : ι) → Decidable (j ∈ s)
i : ι
hi : i ∈ s
⊢ s.piecewise f g i = f i
state_after: no goals
Theorem: Subsemigroup.mem_sSup_of_mem
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

tactic: have : s ≤ sSup S := le_sSup hs
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
s : Subsemigroup M
hs : s ∈ S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
s : Subsemigroup M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: tauto
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
s : Subsemigroup M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: no goals
Theorem: Multiset.filter_eq_self
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
_l : List α
⊢ List.filter (fun b => decide (p b)) _l = _l ↔ ∀ a ∈ Quot.mk Setoid.r _l, p a
state_after: no goals