1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousLinearMap.opNorm_bound_of_ball_bound
File: Mathlib/Analysis/NormedSpace/RCLike.lean

tactic: apply ContinuousLinearMap.opNorm_le_bound
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ ‖f‖ ≤ c / r
state_after: case hMp
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ 0 ≤ c / r

case hM
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ ∀ (x : E), ‖f x‖ ≤ c / r * ‖x‖

tactic: apply LinearMap.bound_of_ball_bound' r_pos
state_before: case hM
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ ∀ (x : E), ‖f x‖ ≤ c / r * ‖x‖
state_after: case hM.h
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ ∀ z ∈ closedBall 0 r, ‖↑f z‖ ≤ c

tactic: exact fun z hz => h z hz
state_before: case hM.h
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ ∀ z ∈ closedBall 0 r, ‖↑f z‖ ≤ c
state_after: no goals

tactic: apply div_nonneg _ r_pos.le
state_before: case hMp
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ 0 ≤ c / r
state_after: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ 0 ≤ c

tactic: exact
  (norm_nonneg _).trans
    (h 0 (by simp only [norm_zero, mem_closedBall, dist_zero_left, r_pos.le]))
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ 0 ≤ c
state_after: no goals

tactic: simp only [norm_zero, mem_closedBall, dist_zero_left, r_pos.le]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_pos : 0 < r
c : ℝ
f : E →L[𝕜] 𝕜
h : ∀ z ∈ closedBall 0 r, ‖f z‖ ≤ c
⊢ 0 ∈ closedBall 0 r
state_after: no goals
Theorem: Int.map_round
File: Mathlib/Algebra/Order/Floor.lean

tactic: have H : f 2 = 2 := map_natCast f 2
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedField α
inst✝⁴ : LinearOrderedField β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
⊢ round (f a) = round a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedField α
inst✝⁴ : LinearOrderedField β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
H : f 2 = 2
⊢ round (f a) = round a

tactic: simp_rw [round_eq, ← map_floor _ hf, map_add, one_div, map_inv₀, H]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedField α
inst✝⁴ : LinearOrderedField β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
H : f 2 = 2
⊢ round (f a) = round a
state_after: no goals
Theorem: CategoryTheory.flat_of_preservesFiniteLimits
File: Mathlib/CategoryTheory/Functor/Flat.lean

tactic: apply hasFiniteLimits_of_hasFiniteLimits_of_size.{v₁} (StructuredArrow X F)
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
⊢ HasFiniteLimits (StructuredArrow X F)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
⊢ ∀ (J : Type v₁) {𝒥 : SmallCategory J}, FinCategory J → HasLimitsOfShape J (StructuredArrow X F)

tactic: intro J sJ fJ
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
⊢ ∀ (J : Type v₁) {𝒥 : SmallCategory J}, FinCategory J → HasLimitsOfShape J (StructuredArrow X F)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
J : Type v₁
sJ : SmallCategory J
fJ : FinCategory J
⊢ HasLimitsOfShape J (StructuredArrow X F)

tactic: constructor
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
J : Type v₁
sJ : SmallCategory J
fJ : FinCategory J
⊢ HasLimitsOfShape J (StructuredArrow X F)
state_after: case has_limit
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
J : Type v₁
sJ : SmallCategory J
fJ : FinCategory J
⊢ autoParam (∀ (F_1 : J ⥤ StructuredArrow X F), HasLimit F_1) _auto✝

tactic: infer_instance
state_before: case has_limit
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasFiniteLimits C
F : C ⥤ D
inst✝ : PreservesFiniteLimits F
X : D
J : Type v₁
sJ : SmallCategory J
fJ : FinCategory J
⊢ autoParam (∀ (F_1 : J ⥤ StructuredArrow X F), HasLimit F_1) _auto✝
state_after: no goals
Theorem: MeasurableEquiv.map_apply_eq_iff_map_symm_apply_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← (map_measurableEquiv_injective e).eq_iff, map_map_symm, eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
⊢ Measure.map (⇑e) μ = ν ↔ Measure.map (⇑e.symm) ν = μ
state_after: no goals
Theorem: LinearMap.BilinForm.comp_id_right
File: Mathlib/LinearAlgebra/BilinearForm/Hom.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
l : M →ₗ[R] M
⊢ B.comp l id = B.compLeft l
state_after: case H
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
l : M →ₗ[R] M
x✝ y✝ : M
⊢ ((B.comp l id) x✝) y✝ = ((B.compLeft l) x✝) y✝

tactic: rfl
state_before: case H
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
l : M →ₗ[R] M
x✝ y✝ : M
⊢ ((B.comp l id) x✝) y✝ = ((B.compLeft l) x✝) y✝
state_after: no goals
Theorem: Finset.uIcc_eq_union
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: push_cast
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ ↑[[a, b]] = ↑(Icc a b ∪ Icc b a)
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a b = Set.Icc a b ∪ Set.Icc b a

tactic: exact Set.uIcc_eq_union
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a b = Set.Icc a b ∪ Set.Icc b a
state_after: no goals
Theorem: LieSubmodule.lie_bot
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [eq_bot_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I, ⊥⁆ = ⊥
state_after: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ∀ m ∈ ⁅I, ⊥⁆, m = 0

tactic: apply lie_le_right
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ∀ m ∈ ⁅I, ⊥⁆, m = 0
state_after: no goals
Theorem: Batteries.DList.toList_cons
File: Mathlib/Data/DList/Defs.lean

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

tactic: simp
state_before: case mk
α : Type u
x : α
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ (cons x { apply := apply✝, invariant := invariant✝ }).toList =
    x :: { apply := apply✝, invariant := invariant✝ }.toList
state_after: no goals
Theorem: Substring.Valid.all
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [h.all, h.toString]
state_before: f : Char → Bool
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ x✝.all f = x✝.toString.data.all f
state_after: no goals
Theorem: Nat.recDiag_succ_zero
File: .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean

tactic: simp [Nat.recDiag]
state_before: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0)
state_after: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0)

tactic: cases m <;> rfl
state_before: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0)
state_after: no goals
Theorem: List.zipWithLeft_eq_zipWithLeftTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: funext α β γ f as bs
state_before: ⊢ @zipWithLeft = @zipWithLeftTR
state_after: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs : List β
⊢ zipWithLeft f as bs = zipWithLeftTR f as bs

tactic: simp [zipWithLeftTR]
state_before: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs : List β
⊢ zipWithLeft f as bs = zipWithLeftTR f as bs
state_after: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs : List β
⊢ zipWithLeft f as bs = zipWithLeftTR.go f as bs #[]

tactic: simp [zipWithLeftTR, go]
state_before: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs : List β
⊢ zipWithLeft f as bs = zipWithLeftTR.go f as bs #[]
state_after: no goals

tactic: simp [zipWithLeftTR.go]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs✝ : List β
acc : Array γ
bs : List β
⊢ zipWithLeftTR.go f [] bs acc = acc.toList ++ zipWithLeft f [] bs
state_after: no goals

tactic: simp [zipWithLeftTR.go, Array.foldl_data_eq_map]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as : List α
bs : List β
acc : Array γ
head✝ : α
tail✝ : List α
⊢ zipWithLeftTR.go f (head✝ :: tail✝) [] acc = acc.toList ++ zipWithLeft f (head✝ :: tail✝) []
state_after: no goals

tactic: simp [zipWithLeftTR.go, go _ as bs]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → Option β → γ
as✝ : List α
bs✝ : List β
acc : Array γ
a : α
as : List α
b : β
bs : List β
⊢ zipWithLeftTR.go f (a :: as) (b :: bs) acc = acc.toList ++ zipWithLeft f (a :: as) (b :: bs)
state_after: no goals
Theorem: ProbabilityTheory.kernel.integral_density
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

tactic: rw [← integral_univ, setIntegral_density_of_measurableSet hκν 0 a hs MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
hκν : fst κ ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
⊢ ∫ (x : γ), density κ ν a x s ∂ν a = ((κ a) (univ ×ˢ s)).toReal
state_after: no goals
Theorem: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cocone F
P : IsColimit s
Q : IsColimit t
⊢ ∀ (j : J), s.ι.app j ≫ (P.coconePointUniqueUpToIso Q).hom ≫ Q.desc r = r.ι.app j
state_after: no goals
Theorem: MeasureTheory.lintegral_biUnion_finset₀
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [← Finset.mem_coe, lintegral_biUnion₀ s.countable_toSet hm hd, ← Finset.tsum_subtype']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
s : Finset β
t : β → Set α
hd : (↑s).Pairwise (AEDisjoint μ on t)
hm : ∀ b ∈ s, NullMeasurableSet (t b) μ
f : α → ℝ≥0∞
⊢ ∫⁻ (a : α) in ⋃ b ∈ s, t b, f a ∂μ = ∑ b ∈ s, ∫⁻ (a : α) in t b, f a ∂μ
state_after: no goals
Theorem: HasDerivAt.comp_hasDerivWithinAt_of_eq
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: rw [hy] at hh₂
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivAt h₂ h₂' y
hh : HasDerivWithinAt h h' s x
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivAt h₂ h₂' (h x)
hh : HasDerivWithinAt h h' s x
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x

tactic: exact hh₂.comp_hasDerivWithinAt x hh
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : HasDerivAt h₂ h₂' (h x)
hh : HasDerivWithinAt h h' s x
hy : y = h x
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x
state_after: no goals
Theorem: smul_unitBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [_root_.smul_ball hc, smul_zero, mul_one]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
hc : c ≠ 0
⊢ c • ball 0 1 = ball 0 ‖c‖
state_after: no goals
Theorem: GaloisField.card
File: Mathlib/FieldTheory/Finite/GaloisField.lean

tactic: let b := IsNoetherian.finsetBasis (ZMod p) (GaloisField p n)
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
h : n ≠ 0
⊢ Fintype.card (GaloisField p n) = p ^ n
state_after: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
h : n ≠ 0
b : Basis { x // x ∈ IsNoetherian.finsetBasisIndex (ZMod p) (GaloisField p n) } (ZMod p) (GaloisField p n) :=
  IsNoetherian.finsetBasis (ZMod p) (GaloisField p n)
⊢ Fintype.card (GaloisField p n) = p ^ n

tactic: rw [Module.card_fintype b, ← FiniteDimensional.finrank_eq_card_basis b, ZMod.card, finrank p h]
state_before: p✝ : ℕ
inst✝ : Fact (Nat.Prime p✝)
n✝ p : ℕ
h_prime : Fact (Nat.Prime p)
n : ℕ
h : n ≠ 0
b : Basis { x // x ∈ IsNoetherian.finsetBasisIndex (ZMod p) (GaloisField p n) } (ZMod p) (GaloisField p n) :=
  IsNoetherian.finsetBasis (ZMod p) (GaloisField p n)
⊢ Fintype.card (GaloisField p n) = p ^ n
state_after: no goals
Theorem: CategoryTheory.eq_of_comp_left_eq
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert w (𝟙 Y) <;> simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h
⊢ f = g
state_after: no goals
Theorem: exterior_minimal
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: rw [exterior_def]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a x y : α
h₁ : s ⊆ t
h₂ : IsOpen t
⊢ exterior s ⊆ t
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a x y : α
h₁ : s ⊆ t
h₂ : IsOpen t
⊢ ⋂₀ {t | IsOpen t ∧ s ⊆ t} ⊆ t

tactic: exact sInter_subset_of_mem ⟨h₂, h₁⟩
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a x y : α
h₁ : s ⊆ t
h₂ : IsOpen t
⊢ ⋂₀ {t | IsOpen t ∧ s ⊆ t} ⊆ t
state_after: no goals
Theorem: CategoryTheory.Iso.homCongr_trans
File: Mathlib/CategoryTheory/Conj.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X₁ Y₁ X₂ Y₂ X₃ Y₃ : C
α₁ : X₁ ≅ X₂
β₁ : Y₁ ≅ Y₂
α₂ : X₂ ≅ X₃
β₂ : Y₂ ≅ Y₃
f : X₁ ⟶ Y₁
⊢ ((α₁ ≪≫ α₂).homCongr (β₁ ≪≫ β₂)) f = ((α₁.homCongr β₁).trans (α₂.homCongr β₂)) f
state_after: no goals
Theorem: SimpleGraph.IsClique.finsetMap
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s✝ t✝ : Set α
a b : α
inst✝ : DecidableEq β
f✝ : α ↪ β
t : Finset β
f : α ↪ β
s : Finset α
h : G.IsClique ↑s
⊢ (SimpleGraph.map f G).IsClique ↑(map f s)
state_after: no goals
Theorem: padicValNat_mul_div_factorial
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: nth_rw 2 [← div_add_mod n p]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
⊢ padicValNat p (p * (n / p))! = padicValNat p n !
state_after: p n : ℕ
hp : Fact (Nat.Prime p)
⊢ padicValNat p (p * (n / p))! = padicValNat p (p * (n / p) + n % p)!

tactic: exact (padicValNat_factorial_mul_add (n / p) <| mod_lt n hp.out.pos).symm
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
⊢ padicValNat p (p * (n / p))! = padicValNat p (p * (n / p) + n % p)!
state_after: no goals
Theorem: IsCompact.exists_infDist_eq_dist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infDist, dist_edist, hy]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
h : IsCompact s
hne : s.Nonempty
x y : α
hys : y ∈ s
hy : infEdist x s = edist x y
⊢ infDist x s = dist x y
state_after: no goals
Theorem: Quandle.conj_swap
File: Mathlib/Algebra/Quandle.lean

tactic: dsimp [Conj] at *
state_before: Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x ◃ y = y ↔ y ◃ x = x
state_after: Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y ↔ y * x * y⁻¹ = x

tactic: constructor
state_before: Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y ↔ y * x * y⁻¹ = x
state_after: case mp
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y → y * x * y⁻¹ = x

case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y

tactic: repeat' intro h; conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
state_before: case mp
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y → y * x * y⁻¹ = x

case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y
state_after: no goals

tactic: intro h
state_before: case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y
state_after: case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
⊢ x * y * x⁻¹ = y

tactic: conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
state_before: case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
⊢ x * y * x⁻¹ = y
state_after: no goals