tasksource/leandojo huggingface dataset:
Theorem: Ordinal.bsup_le_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← familyOfBFamily_enum o f]
state_before: α : Type ?u.309348
β : Type ?u.309351
γ : Type ?u.309354
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
a : Ordinal
h : ∀ (i : (Quotient.out o).α), familyOfBFamily o f i ≤ a
i : Ordinal
hi : i < o
⊢ f i hi ≤ a

tactic: exact h _
state_before: α : Type ?u.309348
β : Type ?u.309351
γ : Type ?u.309354
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
a : Ordinal
h : ∀ (i : (Quotient.out o).α), familyOfBFamily o f i ≤ a
i : Ordinal
hi : i < o
⊢ familyOfBFamily o f (enum (fun x x_1 => x < x_1) i (_ : i < type fun x x_1 => x < x_1)) ≤ a
Theorem: Asymptotics.IsBigOWith.sub
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [sub_eq_add_neg] using h₁.add h₂.neg_left
state_before: α : Type u_1
β : Type ?u.223355
E : Type ?u.223358
F : Type u_3
G : Type ?u.223364
E' : Type u_2
F' : Type ?u.223370
G' : Type ?u.223373
E'' : Type ?u.223376
F'' : Type ?u.223379
G'' : Type ?u.223382
R : Type ?u.223385
R' : Type ?u.223388
𝕜 : Type ?u.223391
𝕜' : Type ?u.223394
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : IsBigOWith c₁ l f₁ g
h₂ : IsBigOWith c₂ l f₂ g
⊢ IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g
Theorem: List.set_comm
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
a b : α
x✝² x✝¹ : Nat
x✝ : x✝² ≠ x✝¹
⊢ set (set [] x✝² a) x✝¹ b = set (set [] x✝¹ b) x✝² a

tactic: simp [set]
state_before: α : Type u_1
a b : α
n : Nat
head✝ : α
tail✝ : List α
x✝ : n + 1 ≠ 0
⊢ set (set (head✝ :: tail✝) (n + 1) a) 0 b = set (set (head✝ :: tail✝) 0 b) (n + 1) a

tactic: simp [set]
state_before: α : Type u_1
a b : α
m : Nat
head✝ : α
tail✝ : List α
x✝ : 0 ≠ m + 1
⊢ set (set (head✝ :: tail✝) 0 a) (m + 1) b = set (set (head✝ :: tail✝) (m + 1) b) 0 a
Theorem: LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_map
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [derivedSeries_eq_derivedSeriesOfIdeal_comap, map_comap_incl, inf_eq_right]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ map (incl I) (derivedSeries R { x // x ∈ ↑I } k) = derivedSeriesOfIdeal R L k I

tactic: apply derivedSeriesOfIdeal_le_self
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ derivedSeriesOfIdeal R L k I ≤ I
Theorem: ContinuousLinearMap.hasStrictFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Linear.lean

tactic: simp only [e.map_sub, sub_self]
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.13611
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.13706
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
x✝ : E
x : E × E
⊢ 0 = ↑e x.fst - ↑e x.snd - ↑e (x.fst - x.snd)
Theorem: MonoidWithZeroHom.ext_rat'
File: Mathlib/Data/Rat/Cast.lean

tactic: rw [← r.num_div_den, div_eq_mul_inv, map_mul, map_mul, h, ← Int.cast_ofNat,
  eq_on_inv₀ f g]
state_before: F : Type u_2
ι : Type ?u.82971
α : Type ?u.82974
β : Type ?u.82977
M₀ : Type u_1
inst✝¹ : MonoidWithZero M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
h : ∀ (m : ℤ), ↑f ↑m = ↑g ↑m
r : ℚ
⊢ ↑f r = ↑g r

tactic: apply h
state_before: F : Type u_2
ι : Type ?u.82971
α : Type ?u.82974
β : Type ?u.82977
M₀ : Type u_1
inst✝¹ : MonoidWithZero M₀
inst✝ : MonoidWithZeroHomClass F ℚ M₀
f g : F
h : ∀ (m : ℤ), ↑f ↑m = ↑g ↑m
r : ℚ
⊢ ↑f ↑↑r.den = ↑g ↑↑r.den
Theorem: IsMaxFilter.sub
File: Mathlib/Order/Filter/Extr.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMaxFilter f l a
hg : IsMinFilter g l a
⊢ IsMaxFilter (fun x => f x - g x) l a
Theorem: HasFPowerSeriesOnBall.eventually_hasSum
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: filter_upwards [EMetric.ball_mem_nhds (0 : E) hf.r_pos]using fun _ => hf.hasSum
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.445837
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
⊢ ∀ᶠ (y : E) in 𝓝 0, HasSum (fun n => ↑(p n) fun x => y) (f (x + y))
Theorem: invOf_exp_of_mem_ball
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: letI := invertibleExpOfMemBall hx
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
𝔹 : Type ?u.124210
inst✝⁷ : NontriviallyNormedField 𝕂
inst✝⁶ : NormedRing 𝔸
inst✝⁵ : NormedRing 𝔹
inst✝⁴ : NormedAlgebra 𝕂 𝔸
inst✝³ : NormedAlgebra 𝕂 𝔹
inst✝² : CompleteSpace 𝔸
inst✝¹ : CharZero 𝕂
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
inst✝ : Invertible (exp 𝕂 x)
⊢ ⅟(exp 𝕂 x) = exp 𝕂 (-x)

tactic: convert(rfl : ⅟ (exp 𝕂 x) = _)
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
𝔹 : Type ?u.124210
inst✝⁷ : NontriviallyNormedField 𝕂
inst✝⁶ : NormedRing 𝔸
inst✝⁵ : NormedRing 𝔹
inst✝⁴ : NormedAlgebra 𝕂 𝔸
inst✝³ : NormedAlgebra 𝕂 𝔹
inst✝² : CompleteSpace 𝔸
inst✝¹ : CharZero 𝕂
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
inst✝ : Invertible (exp 𝕂 x)
this : Invertible (exp 𝕂 x) := invertibleExpOfMemBall hx
⊢ ⅟(exp 𝕂 x) = exp 𝕂 (-x)
Theorem: minpoly.monic
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: delta minpoly
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.2178
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ Monic (minpoly A x)

tactic: rw [dif_pos hx]
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.2178
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ Monic
    (if hx : IsIntegral A x then
      WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
        (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A B) x x_1 = 0) hx
    else 0)

tactic: exact (degree_lt_wf.min_mem _ hx).1
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.2178
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ Monic
    (WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
      (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A B) x x_1 = 0) hx)
Theorem: Option.pmap_map
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [map_none', map_some', pmap]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.7286
p : α → Prop
f : (a : α) → p a → β
x✝ : Option α
g : γ → α
x : Option γ
H : ∀ (a : α), a ∈ Option.map g x → p a
⊢ pmap f (Option.map g x) H = pmap (fun a h => f (g a) h) x (_ : ∀ (a : γ), a ∈ x → p (g a))
Theorem: Finset.prod_range_cast_nat_sub
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: rw [prod_natCast]
state_before: α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f g : α → β
R : Type u_1
inst✝ : CommRing R
n k : ℕ
⊢ ∏ i in range k, (↑n - ↑i) = ↑(∏ i in range k, (n - i))

tactic: cases' le_or_lt k n with hkn hnk
state_before: α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f g : α → β
R : Type u_1
inst✝ : CommRing R
n k : ℕ
⊢ ∏ i in range k, (↑n - ↑i) = ∏ x in range k, ↑(n - x)

tactic: exact prod_congr rfl fun i hi => (Nat.cast_sub <| (mem_range.1 hi).le.trans hkn).symm
state_before: case inl
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f g : α → β
R : Type u_1
inst✝ : CommRing R
n k : ℕ
hkn : k ≤ n
⊢ ∏ i in range k, (↑n - ↑i) = ∏ x in range k, ↑(n - x)

tactic: rw [← mem_range] at hnk
state_before: case inr
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f g : α → β
R : Type u_1
inst✝ : CommRing R
n k : ℕ
hnk : n < k
⊢ ∏ i in range k, (↑n - ↑i) = ∏ x in range k, ↑(n - x)

tactic: rw [prod_eq_zero hnk, prod_eq_zero hnk] <;> simp
state_before: case inr
α : Type u
β : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
b : β
f g : α → β
R : Type u_1
inst✝ : CommRing R
n k : ℕ
hnk : n ∈ range k
⊢ ∏ i in range k, (↑n - ↑i) = ∏ x in range k, ↑(n - x)
Theorem: or_and_right
File: Std/Logic.lean

tactic: simp [and_comm, and_or_left]
state_before: a b c : Prop
⊢ (a ∨ b) ∧ c ↔ a ∧ c ∨ b ∧ c
Theorem: bernoulli'_three
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: rw [bernoulli'_def, sum_range_succ, sum_range_succ, sum_range_succ, sum_range_zero]
state_before: A : Type ?u.186788
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 3 = 0

tactic: norm_num
state_before: A : Type ?u.186788
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 -
      (0 + ↑(Nat.choose 3 0) / (↑3 - ↑0 + 1) * bernoulli' 0 + ↑(Nat.choose 3 1) / (↑3 - ↑1 + 1) * bernoulli' 1 +
        ↑(Nat.choose 3 2) / (↑3 - ↑2 + 1) * bernoulli' 2) =
    0
Theorem: CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s_comp_π_succ
File: Mathlib/AlgebraicTopology/ExtraDegeneracy.lean

tactic: dsimp [ExtraDegeneracy.s]
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
i : Fin (n + 1)
⊢ s f S n ≫ WidePullback.π (fun x => f.hom) (Fin.succ i) = WidePullback.π (fun x => f.hom) i

tactic: simp only [WidePullback.lift_π]
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
i : Fin (n + 1)
⊢ WidePullback.lift (WidePullback.base fun x => f.hom)
        (fun i =>
          if x : i = 0 then (WidePullback.base fun x => f.hom) ≫ S.section_
          else WidePullback.π (fun x => f.hom) (Fin.pred i x))
        (_ :
          ∀ (i : Fin (SimplexCategory.len [n + 1].op.unop + 1)),
            (fun i =>
                    if x : i = 0 then (WidePullback.base fun x => f.hom) ≫ S.section_
                    else WidePullback.π (fun x => f.hom) (Fin.pred i x))
                  i ≫
                f.hom =
              WidePullback.base fun x => f.hom) ≫
      WidePullback.π (fun x => f.hom) (Fin.succ i) =
    WidePullback.π (fun x => f.hom) i

tactic: split_ifs with h
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
i : Fin (n + 1)
⊢ (if x : Fin.succ i = 0 then (WidePullback.base fun x => f.hom) ≫ S.section_
    else WidePullback.π (fun x => f.hom) (Fin.pred (Fin.succ i) x)) =
    WidePullback.π (fun x => f.hom) i

tactic: simp only [Fin.ext_iff, Fin.val_succ, Fin.val_zero, add_eq_zero, and_false] at h
state_before: case inl
C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
i : Fin (n + 1)
h : Fin.succ i = 0
⊢ (WidePullback.base fun x => f.hom) ≫ S.section_ = WidePullback.π (fun x => f.hom) i

tactic: simp only [Fin.pred_succ]
state_before: case inr
C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
i : Fin (n + 1)
h : ¬Fin.succ i = 0
⊢ WidePullback.π (fun x => f.hom) (Fin.pred (Fin.succ i) h) = WidePullback.π (fun x => f.hom) i
Theorem: Part.union_mem_union
File: Mathlib/Data/Part.lean

tactic: simp [union_def]
state_before: α : Type u_1
β : Type ?u.88814
γ : Type ?u.88817
inst✝ : Union α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ma ∪ mb ∈ a ∪ b

tactic: aesop
state_before: α : Type u_1
β : Type ?u.88814
γ : Type ?u.88817
inst✝ : Union α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1, a_1 ∈ a ∧ ∃ a, a ∈ b ∧ a_1 ∪ a = ma ∪ mb
Theorem: Ordinal.CNF_of_le_one
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: rcases le_one_iff.1 hb with (rfl | rfl)
state_before: b o : Ordinal
hb : b ≤ 1
ho : o ≠ 0
⊢ CNF b o = [(0, o)]

tactic: exact zero_CNF ho
state_before: case inl
o : Ordinal
ho : o ≠ 0
hb : 0 ≤ 1
⊢ CNF 0 o = [(0, o)]

tactic: exact one_CNF ho
state_before: case inr
o : Ordinal
ho : o ≠ 0
hb : 1 ≤ 1
⊢ CNF 1 o = [(0, o)]
Theorem: MeasureTheory.Measure.restrict_singleton
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
⊢ restrict μ {a} = ↑↑μ {a} • dirac a

tactic: by_cases ha : a ∈ s
state_before: case h
α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
⊢ ↑↑(restrict μ {a}) s = ↑↑(↑↑μ {a} • dirac a) s

tactic: have : s ∩ {a} = {a} := by simpa
state_before: case pos
α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : a ∈ s
⊢ ↑↑(restrict μ {a}) s = ↑↑(↑↑μ {a} • dirac a) s

tactic: simp [*]
state_before: case pos
α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : a ∈ s
this : s ∩ {a} = {a}
⊢ ↑↑(restrict μ {a}) s = ↑↑(↑↑μ {a} • dirac a) s

tactic: simpa
state_before: α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : a ∈ s
⊢ s ∩ {a} = {a}

tactic: have : s ∩ {a} = ∅ := inter_singleton_eq_empty.2 ha
state_before: case neg
α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : ¬a ∈ s
⊢ ↑↑(restrict μ {a}) s = ↑↑(↑↑μ {a} • dirac a) s

tactic: simp [*]
state_before: case neg
α : Type u_1
β : Type ?u.331505
γ : Type ?u.331508
δ : Type ?u.331511
ι : Type ?u.331514
R : Type ?u.331517
R' : Type ?u.331520
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
μ : Measure α
a : α
s : Set α
hs : MeasurableSet s
ha : ¬a ∈ s
this : s ∩ {a} = ∅
⊢ ↑↑(restrict μ {a}) s = ↑↑(↑↑μ {a} • dirac a) s
Theorem: intervalIntegral.measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab hmeas
    stronglyMeasurableAt_bot hf ((tendsto_bot : Tendsto _ ⊥ (𝓝 (0 : E))).mono_left inf_le_left) hu
    hv (tendsto_const_pure : Tendsto _ _ (pure b)) tendsto_const_pure
state_before: ι : Type u_2
𝕜 : Type ?u.1482776
E : Type u_1
F : Type ?u.1482782
A : Type ?u.1482785
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedSpace ℝ E
f : ℝ → E
a b : ℝ
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
μ : MeasureTheory.Measure ℝ
u v ua va ub vb : ι → ℝ
inst✝² : FTCFilter a la la'
inst✝¹ : FTCFilter b lb lb'
inst✝ : IsLocallyFiniteMeasure μ
hab : IntervalIntegrable f μ a b
hmeas : StronglyMeasurableAtFilter f la'
hf : Tendsto f (la' ⊓ Measure.ae μ) (𝓝 c)
hu : Tendsto u lt la
hv : Tendsto v lt la
⊢ (fun t => ((∫ (x : ℝ) in v t..b, f x ∂μ) - ∫ (x : ℝ) in u t..b, f x ∂μ) + ∫ (x : ℝ) in u t..v t, c ∂μ) =o[lt] fun t =>
    ∫ (x : ℝ) in u t..v t, 1 ∂μ
Theorem: Polynomial.card_roots_toFinset_le_card_roots_derivative_diff_roots_succ
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: cases' eq_or_ne (derivative p) 0 with hp' hp'
state_before: p : ℝ[X]
⊢ Finset.card (Multiset.toFinset (roots p)) ≤
    Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1

tactic: have hp : p ≠ 0 := ne_of_apply_ne derivative (by rwa [derivative_zero])
state_before: case inr
p : ℝ[X]
hp' : ↑derivative p ≠ 0
⊢ Finset.card (Multiset.toFinset (roots p)) ≤
    Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1

tactic: refine' Finset.card_le_diff_of_interleaved fun x hx y hy hxy hxy' => _
state_before: case inr
p : ℝ[X]
hp' : ↑derivative p ≠ 0
hp : p ≠ 0
⊢ Finset.card (Multiset.toFinset (roots p)) ≤
    Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1

tactic: rw [Multiset.mem_toFinset, mem_roots hp] at hx hy
state_before: case inr
p : ℝ[X]
hp' : ↑derivative p ≠ 0
hp : p ≠ 0
x : ℝ
hx : x ∈ Multiset.toFinset (roots p)
y : ℝ
hy : y ∈ Multiset.toFinset (roots p)
hxy : x < y
hxy' : ∀ (z : ℝ), z ∈ Multiset.toFinset (roots p) → ¬z ∈ Ioo x y
⊢ ∃ z, z ∈ Multiset.toFinset (roots (↑derivative p)) ∧ x < z ∧ z < y

tactic: obtain ⟨z, hz1, hz2⟩ :=
  exists_deriv_eq_zero (fun x : ℝ => eval x p) hxy p.continuousOn (hx.trans hy.symm)
state_before: case inr
p : ℝ[X]
hp' : ↑derivative p ≠ 0
hp : p ≠ 0
x : ℝ
hx : IsRoot p x
y : ℝ
hy : IsRoot p y
hxy : x < y
hxy' : ∀ (z : ℝ), z ∈ Multiset.toFinset (roots p) → ¬z ∈ Ioo x y
⊢ ∃ z, z ∈ Multiset.toFinset (roots (↑derivative p)) ∧ x < z ∧ z < y

tactic: refine' ⟨z, _, hz1⟩
state_before: case inr.intro.intro
p : ℝ[X]
hp' : ↑derivative p ≠ 0
hp : p ≠ 0
x : ℝ
hx : IsRoot p x
y : ℝ
hy : IsRoot p y
hxy : x < y
hxy' : ∀ (z : ℝ), z ∈ Multiset.toFinset (roots p) → ¬z ∈ Ioo x y
z : ℝ
hz1 : z ∈ Ioo x y
hz2 : deriv (fun x => eval x p) z = 0
⊢ ∃ z, z ∈ Multiset.toFinset (roots (↑derivative p)) ∧ x < z ∧ z < y

tactic: rwa [Multiset.mem_toFinset, mem_roots hp', IsRoot, ← p.deriv]
state_before: case inr.intro.intro
p : ℝ[X]
hp' : ↑derivative p ≠ 0
hp : p ≠ 0
x : ℝ
hx : IsRoot p x
y : ℝ
hy : IsRoot p y
hxy : x < y
hxy' : ∀ (z : ℝ), z ∈ Multiset.toFinset (roots p) → ¬z ∈ Ioo x y
z : ℝ
hz1 : z ∈ Ioo x y
hz2 : deriv (fun x => eval x p) z = 0
⊢ z ∈ Multiset.toFinset (roots (↑derivative p))

tactic: rw [eq_C_of_derivative_eq_zero hp', roots_C, Multiset.toFinset_zero, Finset.card_empty]
state_before: case inl
p : ℝ[X]
hp' : ↑derivative p = 0
⊢ Finset.card (Multiset.toFinset (roots p)) ≤
    Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1

tactic: exact zero_le _
state_before: case inl
p : ℝ[X]
hp' : ↑derivative p = 0
⊢ 0 ≤ Finset.card (Multiset.toFinset (roots (↑derivative (↑C (coeff p 0)))) \ ∅) + 1

tactic: rwa [derivative_zero]
state_before: p : ℝ[X]
hp' : ↑derivative p ≠ 0
⊢ ↑derivative p ≠ ↑derivative 0
Theorem: Polynomial.root_mul
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp_rw [IsRoot, eval_mul, mul_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
⊢ IsRoot (p * q) a ↔ IsRoot p a ∨ IsRoot q a
Theorem: Nat.Partrec'.map
File: Mathlib/Computability/Halting.lean

tactic: simp [(Part.bind_some_eq_map _ _).symm]
state_before: n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) → ℕ
hf : Partrec' f
hg : Partrec' ↑g
⊢ Partrec' fun v => Part.map (fun a => g (a ::ᵥ v)) (f v)

tactic: exact hf.bind hg
state_before: n : ℕ
f : Vector ℕ n →. ℕ
g : Vector ℕ (n + 1) → ℕ
hf : Partrec' f
hg : Partrec' ↑g
⊢ Partrec' fun v => Part.bind (f v) (Part.some ∘ fun a => g (a ::ᵥ v))
Theorem: CategoryTheory.Limits.inr_pushoutAssoc_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← Iso.eq_comp_inv, Category.assoc, inr_inr_pushoutAssoc_inv]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).hom = pushout.inr ≫ pushout.inr
Theorem: IsUnit.exists_right_inv
File: Mathlib/Algebra/Group/Units.lean

tactic: rcases h with ⟨⟨a, b, hab, _⟩, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type ?u.56747
inst✝ : Monoid M
a : M
h : IsUnit a
⊢ ∃ b, a * b = 1

tactic: exact ⟨b, hab⟩
state_before: case intro.mk
α : Type u
M : Type u_1
N : Type ?u.56747
inst✝ : Monoid M
a b : M
hab : a * b = 1
inv_val✝ : b * a = 1
⊢ ∃ b_1, ↑{ val := a, inv := b, val_inv := hab, inv_val := inv_val✝ } * b_1 = 1
Theorem: Ordinal.lift_le
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← lift_umax]
state_before: α✝ : Type ?u.110770
β✝ : Type ?u.110773
γ : Type ?u.110776
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type v
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type v
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ lift (type r) ≤ lift (type s) ↔ type r ≤ type s

tactic: exact lift_type_le.{_,_,u}
state_before: α✝ : Type ?u.110770
β✝ : Type ?u.110773
γ : Type ?u.110776
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type v
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type v
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ lift (type r) ≤ lift (type s) ↔ type r ≤ type s
Theorem: EMetric.infEdist_le_edist_add_infEdist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [add_comm]
state_before: ι : Sort ?u.7435
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
⊢ infEdist x s ≤ edist x y + infEdist y s

tactic: exact infEdist_le_infEdist_add_edist
state_before: ι : Sort ?u.7435
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
⊢ infEdist x s ≤ infEdist y s + edist x y
Theorem: Primrec.const
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> rfl
state_before: α : Type u_1
β : Type ?u.22417
σ : Type u_2
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
x : σ
n : ℕ
⊢ (Nat.casesOn (encode (decode n)) 0 fun x_1 => Nat.succ (encode x)) = encode (Option.map (fun x_1 => x) (decode n))
Theorem: div_eq_inv_self
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_left_eq_self]
state_before: α : Type ?u.48927
β : Type ?u.48930
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a / b = b⁻¹ ↔ a = 1
Theorem: Mathlib.Tactic.Ring.div_congr
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R✝ : Type ?u.398864
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a a' b b' c : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' / b' = c
⊢ a / b = c

tactic: rfl
state_before: u : Lean.Level
R✝ : Type ?u.398864
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a' b' : R
⊢ a' / b' = a' / b'