1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Complex.norm_log_one_sub_inv_add_logTaylor_neg_le
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: rw [sub_eq_add_neg,
  log_inv _ <| slitPlane_arg_ne_pi <| mem_slitPlane_of_norm_lt_one <| (norm_neg z).symm ▸ hz,
  ← sub_neg_eq_add, ← neg_sub', norm_neg]
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
⊢ ‖log (1 - z)⁻¹ + logTaylor (n + 1) (-z)‖ ≤ ‖z‖ ^ (n + 1) * (1 - ‖z‖)⁻¹ / (↑n + 1)
state_after: n : ℕ
z : ℂ
hz : ‖z‖ < 1
⊢ ‖log (1 + -z) - logTaylor (n + 1) (-z)‖ ≤ ‖z‖ ^ (n + 1) * (1 - ‖z‖)⁻¹ / (↑n + 1)

tactic: convert norm_log_sub_logTaylor_le n <| (norm_neg z).symm ▸ hz using 4 <;> rw [norm_neg]
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
⊢ ‖log (1 + -z) - logTaylor (n + 1) (-z)‖ ≤ ‖z‖ ^ (n + 1) * (1 - ‖z‖)⁻¹ / (↑n + 1)
state_after: no goals
Theorem: HolderWith.dist_le_of_le
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: lift d to ℝ≥0 using dist_nonneg.trans hd
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ
hd : dist x y ≤ d
⊢ dist (f x) (f y) ≤ ↑C * d ^ ↑r
state_after: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : dist x y ≤ ↑d
⊢ dist (f x) (f y) ≤ ↑C * ↑d ^ ↑r

tactic: rw [dist_nndist] at hd ⊢
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : dist x y ≤ ↑d
⊢ dist (f x) (f y) ≤ ↑C * ↑d ^ ↑r
state_after: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : ↑(nndist x y) ≤ ↑d
⊢ ↑(nndist (f x) (f y)) ≤ ↑C * ↑d ^ ↑r

tactic: norm_cast at hd ⊢
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : ↑(nndist x y) ≤ ↑d
⊢ ↑(nndist (f x) (f y)) ≤ ↑C * ↑d ^ ↑r
state_after: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ nndist (f x) (f y) ≤ C * d ^ ↑r

tactic: exact hf.nndist_le_of_le hd
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ nndist (f x) (f y) ≤ C * d ^ ↑r
state_after: no goals
Theorem: Fin.isThreeCycle_cycleRange_two
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [IsThreeCycle, cycleType_cycleRange] <;> simp [Fin.ext_iff]
state_before: n : ℕ
⊢ (cycleRange 2).IsThreeCycle
state_after: no goals
Theorem: Filter.Tendsto.const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: cases h with
| inl h => exact (continuousAt_const_cpow h).tendsto.comp hf
| inr h => exact (continuousAt_const_cpow' h).tendsto.comp hf
state_before: α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : a ≠ 0 ∨ b ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))
state_after: no goals

tactic: exact (continuousAt_const_cpow h).tendsto.comp hf
state_before: case inl
α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : a ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))
state_after: no goals

tactic: exact (continuousAt_const_cpow' h).tendsto.comp hf
state_before: case inr
α : Type u_1
l : Filter α
f : α → ℂ
a b : ℂ
hf : Tendsto f l (𝓝 b)
h : b ≠ 0
⊢ Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))
state_after: no goals
Theorem: Matroid.map_loopyOn
File: Mathlib/Data/Matroid/Map.lean

tactic: simp [eq_loopyOn_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
hf : InjOn f (loopyOn E).E
⊢ (loopyOn E).map f hf = loopyOn (f '' E)
state_after: no goals
Theorem: Real.sinh_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: rw [sinh_eq, ← arsinh_neg, exp_arsinh, exp_arsinh, neg_sq]
state_before: x✝ y x : ℝ
⊢ sinh (arsinh x) = x
state_after: x✝ y x : ℝ
⊢ (x + √(1 + x ^ 2) - (-x + √(1 + x ^ 2))) / 2 = x

tactic: field_simp
state_before: x✝ y x : ℝ
⊢ (x + √(1 + x ^ 2) - (-x + √(1 + x ^ 2))) / 2 = x
state_after: no goals
Theorem: MeasureTheory.submartingale_of_condexp_sub_nonneg_nat
File: Mathlib/Probability/Martingale/Basic.lean

tactic: refine submartingale_nat hadp hint fun i => ?_
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
⊢ Submartingale f 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ f i ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i]

tactic: rw [← condexp_of_stronglyMeasurable (𝒢.le _) (hadp _) (hint _), ← eventually_sub_nonneg]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ f i ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i]
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ 0 ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i] - μ[f i|↑𝒢 i]

tactic: exact EventuallyLE.trans (hf i) (condexp_sub (hint _) (hint _)).le
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ 0 ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i] - μ[f i|↑𝒢 i]
state_after: no goals
Theorem: Codisjoint.eq_iff
File: Mathlib/Order/Disjoint.lean

tactic: aesop
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
a b c d : α
hab : Codisjoint a b
⊢ a = b ↔ a = ⊤ ∧ b = ⊤
state_after: no goals
Theorem: Cardinal.exists_infinite_fiber
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp_rw [Cardinal.infinite_iff] at w' ⊢
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : Infinite α
⊢ ∃ a, Infinite ↑(f ⁻¹' {a})
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})

tactic: cases' infinite_pigeonhole_card_lt f w w' with a ha
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})
state_after: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
a : α
ha : #α < #↑(f ⁻¹' {a})
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})

tactic: exact ⟨a, w'.trans ha.le⟩
state_before: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
a : α
ha : #α < #↑(f ⁻¹' {a})
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})
state_after: no goals
Theorem: CategoryTheory.SmallObject.ιFunctorObj_πFunctorObj
File: Mathlib/CategoryTheory/SmallObject/Construction.lean

tactic: simp [ιFunctorObj, πFunctorObj]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
I : Type w
A B : I → C
f : (i : I) → A i ⟶ B i
S X Y Z : C
πX : X ⟶ S
πY : Y ⟶ S
φ : X ⟶ Y
hφ : φ ≫ πY = πX
inst✝³ : HasColimitsOfShape (Discrete (FunctorObjIndex f πX)) C
inst✝² : HasColimitsOfShape (Discrete (FunctorObjIndex f πY)) C
inst✝¹ : HasPushout (functorObjTop f πX) (functorObjLeft f πX)
inst✝ : HasPushout (functorObjTop f πY) (functorObjLeft f πY)
⊢ ιFunctorObj f πX ≫ πFunctorObj f πX = πX
state_after: no goals
Theorem: Basis.SmithNormalForm.coord_apply_embedding_eq_smul_coord
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

tactic: ext m
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
i : Fin n
⊢ snf.bM.coord (snf.f i) ∘ₗ N.subtype = snf.a i • snf.bN.coord i
state_after: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m✝ : ↥N
i : Fin n
m : ↥N
⊢ (snf.bM.coord (snf.f i) ∘ₗ N.subtype) m = (snf.a i • snf.bN.coord i) m

tactic: simp [Pi.smul_apply (snf.a i)]
state_before: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m✝ : ↥N
i : Fin n
m : ↥N
⊢ (snf.bM.coord (snf.f i) ∘ₗ N.subtype) m = (snf.a i • snf.bN.coord i) m
state_after: no goals
Theorem: Real.exists_cos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: ⊢ 1 ≤ 2
state_after: no goals
Theorem: Submonoid.mem_iSup
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

tactic: rw [← closure_singleton_le_iff_mem, le_iSup_iff]
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ m ∈ ⨆ i, p i ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ (∀ (b : Submonoid M), (∀ (i : ι), p i ≤ b) → closure {m} ≤ b) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N

tactic: simp only [closure_singleton_le_iff_mem]
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ (∀ (b : Submonoid M), (∀ (i : ι), p i ≤ b) → closure {m} ≤ b) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: no goals
Theorem: Multiset.mem_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← cons_erase h₁, cons_inter_of_pos _ h₂]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ s ∩ t
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ a ::ₘ s.erase a ∩ t.erase a

tactic: apply mem_cons_self
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ a ::ₘ s.erase a ∩ t.erase a
state_after: no goals
Theorem: Units.val_eq_one
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← Units.val_one, eq_iff]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u a : αˣ
⊢ ↑a = 1 ↔ a = 1
state_after: no goals
Theorem: HomologicalComplex.isZero_zero
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: refine ⟨fun X => ⟨⟨⟨0⟩, fun f => ?_⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => ?_⟩⟩⟩
state_before: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
⊢ IsZero zero
state_after: case refine_1
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : zero ⟶ X
⊢ f = default

case refine_2
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
⊢ f = default

tactic: all_goals
  ext
  dsimp [zero]
  apply Subsingleton.elim
state_before: case refine_1
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : zero ⟶ X
⊢ f = default

case refine_2
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
⊢ f = default
state_after: no goals

tactic: ext
state_before: case refine_2
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
⊢ f = default
state_after: case refine_2.h
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ f.f i✝ = default.f i✝

tactic: dsimp [zero]
state_before: case refine_2.h
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ f.f i✝ = default.f i✝
state_after: case refine_2.h
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ f.f i✝ = 0

tactic: apply Subsingleton.elim
state_before: case refine_2.h
ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ f.f i✝ = 0
state_after: no goals
Theorem: MetricSpace.replaceUniformity_eq
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ✝ : Type w
inst✝ : MetricSpace γ✝
γ : Type u_3
U : UniformSpace γ
m : MetricSpace γ
H : 𝓤 γ = 𝓤 γ
⊢ m.replaceUniformity H = m
state_after: case h.dist.h.h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ✝ : Type w
inst✝ : MetricSpace γ✝
γ : Type u_3
U : UniformSpace γ
m : MetricSpace γ
H : 𝓤 γ = 𝓤 γ
x✝¹ x✝ : γ
⊢ dist x✝¹ x✝ = dist x✝¹ x✝

tactic: rfl
state_before: case h.dist.h.h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ✝ : Type w
inst✝ : MetricSpace γ✝
γ : Type u_3
U : UniformSpace γ
m : MetricSpace γ
H : 𝓤 γ = 𝓤 γ
x✝¹ x✝ : γ
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
state_after: no goals
Theorem: hasFDerivAt_inv'
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: simpa using hasFDerivAt_ring_inverse (Units.mk0 _ hx)
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
R : Type u_6
inst✝² : NormedDivisionRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : R
hx : x ≠ 0
⊢ HasFDerivAt Inv.inv (-((mulLeftRight 𝕜 R) x⁻¹) x⁻¹) x
state_after: no goals
Theorem: Nat.ord_proj_dvd_ord_proj_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: refine ⟨fun h => ?_, fun hab p => ord_proj_dvd_ord_proj_of_dvd hb0 hab p⟩
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
⊢ (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a ∣ b

tactic: rw [← factorization_le_iff_dvd ha0 hb0]
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a ∣ b
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a.factorization ≤ b.factorization

tactic: intro q
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
⊢ a.factorization ≤ b.factorization
state_after: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
⊢ a.factorization q ≤ b.factorization q

tactic: rcases le_or_lt q 1 with (hq_le | hq1)
state_before: a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
⊢ a.factorization q ≤ b.factorization q
state_after: case inl
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq_le : q ≤ 1
⊢ a.factorization q ≤ b.factorization q

case inr
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq1 : 1 < q
⊢ a.factorization q ≤ b.factorization q

tactic: exact (pow_dvd_pow_iff_le_right hq1).1 (h q)
state_before: case inr
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq1 : 1 < q
⊢ a.factorization q ≤ b.factorization q
state_after: no goals

tactic: interval_cases q <;> simp
state_before: case inl
a✝ b✝ m n p a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p
q : ℕ
hq_le : q ≤ 1
⊢ a.factorization q ≤ b.factorization q
state_after: no goals
Theorem: MeasurableSpace.measurableSet_sSup
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

tactic: change GenerateMeasurable (⋃₀ _) _ ↔ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ MeasurableSet s ↔ GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ GenerateMeasurable (⋃₀ ((fun m => {t | MeasurableSet t}) '' ms)) s ↔
    GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s

tactic: simp [← setOf_exists]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ GenerateMeasurable (⋃₀ ((fun m => {t | MeasurableSet t}) '' ms)) s ↔
    GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s
state_after: no goals
Theorem: Ideal.add_pow_add_pred_mem_of_pow_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [← Nat.sub_le_iff_le_add]
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
m n : ℕ
ha : a ^ m ∈ I
hb : b ^ n ∈ I
⊢ m + n ≤ m + n - 1 + 1
state_after: no goals
Theorem: Finset.inv_op_smul_finset_distrib₀
File: Mathlib/Data/Finset/Pointwise.lean

tactic: obtain rfl | ha := eq_or_ne a 0
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ (op a • s)⁻¹ = a⁻¹ • s⁻¹
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : DecidableEq α
s : Finset α
⊢ (op 0 • s)⁻¹ = 0⁻¹ • s⁻¹

case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ≠ 0
⊢ (op a • s)⁻¹ = a⁻¹ • s⁻¹

tactic: obtain rfl | hs := s.eq_empty_or_nonempty <;> simp [*]
state_before: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : DecidableEq α
s : Finset α
⊢ (op 0 • s)⁻¹ = 0⁻¹ • s⁻¹
state_after: no goals

tactic: ext
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ≠ 0
⊢ (op a • s)⁻¹ = a⁻¹ • s⁻¹
state_after: case inr.a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝¹ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ≠ 0
a✝ : α
⊢ a✝ ∈ (op a • s)⁻¹ ↔ a✝ ∈ a⁻¹ • s⁻¹

tactic: simp [← inv_smul_mem_iff₀, *]
state_before: case inr.a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝¹ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ≠ 0
a✝ : α
⊢ a✝ ∈ (op a • s)⁻¹ ↔ a✝ ∈ a⁻¹ • s⁻¹
state_after: no goals
Theorem: CategoryTheory.unit_obj_eq_map_unit
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: rw [← cancel_mono (i.map ((reflectorAdjunction i).counit.app ((reflector i).obj X))),
  ← i.map_comp]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : C
⊢ (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) =
    i.map ((reflector i).map ((reflectorAdjunction i).unit.app X))
state_after: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : C
⊢ (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) ≫
      i.map ((reflectorAdjunction i).counit.app ((reflector i).obj X)) =
    i.map
      ((reflector i).map ((reflectorAdjunction i).unit.app X) ≫
        (reflectorAdjunction i).counit.app ((reflector i).obj X))

tactic: simp
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : C
⊢ (reflectorAdjunction i).unit.app (i.obj ((reflector i).obj X)) ≫
      i.map ((reflectorAdjunction i).counit.app ((reflector i).obj X)) =
    i.map
      ((reflector i).map ((reflectorAdjunction i).unit.app X) ≫
        (reflectorAdjunction i).counit.app ((reflector i).obj X))
state_after: no goals
Theorem: iInter_Iic_eq_empty_iff
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp [not_bddBelow_iff, Set.eq_empty_iff_forall_not_mem]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
⊢ ⋂ i, Iic (f i) = ∅ ↔ ¬BddBelow (range f)
state_after: no goals
Theorem: ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_unit_prod
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

tactic: simp_rw [IsMeasurableRatCDF.stieltjesFunctionAux_def']
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
a : α
⊢ stieltjesFunctionAux (fun p => f p.2) ((), a) = stieltjesFunctionAux f a
state_after: no goals
Theorem: WeierstrassCurve.Affine.slope_of_Y_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rw [slope, if_pos hx, if_pos hy]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ = x₂
hy : y₁ = W.negY x₂ y₂
⊢ W.slope x₁ x₂ y₁ y₂ = 0
state_after: no goals