tasksource/leandojo huggingface dataset:
Theorem: Real.pi_lt_3141593
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_upper_bound
    [27720 / 19601, 56935 / 30813, 49359 / 25163, 258754 / 130003, 113599 / 56868,
      1101994 / 551163, 8671537 / 4336095, 3877807 / 1938940, 52483813 / 26242030,
      56946167 / 28473117, 23798415 / 11899211]
state_before: ⊢ π < 3.141593
Theorem: Submonoid.bot_prod_bot
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp [coe_prod, Prod.one_eq_mk]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.100408
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.100429
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ↑(prod ⊥ ⊥) = ↑⊥
Theorem: Real.sqrt_ne_zero
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [not_iff_not, sqrt_eq_zero h]
state_before: x y : ℝ
h : 0 ≤ x
⊢ sqrt x ≠ 0 ↔ x ≠ 0
Theorem: FractionalIdeal.isNoetherian_coeIdeal
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [isNoetherian_iff]
state_before: R : Type ?u.1753199
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1753406
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsNoetherianRing R₁
I : Ideal R₁
⊢ IsNoetherian R₁ { x // x ∈ ↑↑I }

tactic: intro J hJ
state_before: R : Type ?u.1753199
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1753406
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsNoetherianRing R₁
I : Ideal R₁
⊢ ∀ (J : FractionalIdeal R₁⁰ K), J ≤ ↑I → FG ↑J

tactic: obtain ⟨J, rfl⟩ := le_one_iff_exists_coeIdeal.mp (le_trans hJ coeIdeal_le_one)
state_before: R : Type ?u.1753199
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1753406
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsNoetherianRing R₁
I : Ideal R₁
J : FractionalIdeal R₁⁰ K
hJ : J ≤ ↑I
⊢ FG ↑J

tactic: exact (IsNoetherian.noetherian J).map _
state_before: case intro
R : Type ?u.1753199
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1753406
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsNoetherianRing R₁
I J : Ideal R₁
hJ : ↑J ≤ ↑I
⊢ FG ↑↑J
Theorem: DoubleCentralizer.norm_snd
File: Mathlib/Analysis/NormedSpace/Star/Multiplier.lean

tactic: rw [← norm_fst, norm_fst_eq_snd]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing A
inst✝⁴ : NormedSpace 𝕜 A
inst✝³ : SMulCommClass 𝕜 A A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : StarRing A
inst✝ : CstarRing A
a : 𝓜(𝕜, A)
⊢ ‖a.snd‖ = ‖a‖
Theorem: Set.mulIndicator_mul_compl_eq_piecewise
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.72118
ι : Type ?u.72121
M : Type u_2
N : Type ?u.72127
inst✝¹ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
inst✝ : DecidablePred fun x => x ∈ s
f g : α → M
⊢ mulIndicator s f * mulIndicator (sᶜ) g = piecewise s f g

tactic: by_cases h : x ∈ s
state_before: case h
α : Type u_1
β : Type ?u.72118
ι : Type ?u.72121
M : Type u_2
N : Type ?u.72127
inst✝¹ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
inst✝ : DecidablePred fun x => x ∈ s
f g : α → M
x : α
⊢ (mulIndicator s f * mulIndicator (sᶜ) g) x = piecewise s f g x

tactic: rw [piecewise_eq_of_mem _ _ _ h, Pi.mul_apply, Set.mulIndicator_of_mem h,
  Set.mulIndicator_of_not_mem (Set.not_mem_compl_iff.2 h), mul_one]
state_before: case pos
α : Type u_1
β : Type ?u.72118
ι : Type ?u.72121
M : Type u_2
N : Type ?u.72127
inst✝¹ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
inst✝ : DecidablePred fun x => x ∈ s
f g : α → M
x : α
h : x ∈ s
⊢ (mulIndicator s f * mulIndicator (sᶜ) g) x = piecewise s f g x

tactic: rw [piecewise_eq_of_not_mem _ _ _ h, Pi.mul_apply, Set.mulIndicator_of_not_mem h,
  Set.mulIndicator_of_mem (Set.mem_compl h), one_mul]
state_before: case neg
α : Type u_1
β : Type ?u.72118
ι : Type ?u.72121
M : Type u_2
N : Type ?u.72127
inst✝¹ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
inst✝ : DecidablePred fun x => x ∈ s
f g : α → M
x : α
h : ¬x ∈ s
⊢ (mulIndicator s f * mulIndicator (sᶜ) g) x = piecewise s f g x
Theorem: orderOf_pow_coprime
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: by_cases hg : orderOf y = 0
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime (orderOf y) m
⊢ orderOf (y ^ m) = orderOf y

tactic: rw [m.coprime_zero_left.mp (hg ▸ h), pow_one]
state_before: case pos
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime (orderOf y) m
hg : orderOf y = 0
⊢ orderOf (y ^ m) = orderOf y

tactic: rw [orderOf_pow'' y m (hg.imp_symm orderOf_eq_zero), h.gcd_eq_one, Nat.div_one]
state_before: case neg
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime (orderOf y) m
hg : ¬orderOf y = 0
⊢ orderOf (y ^ m) = orderOf y
Theorem: Polynomial.eq_prod_roots_of_splits_id
File: Mathlib/Data/Polynomial/Splits.lean

tactic: simpa using eq_prod_roots_of_splits hsplit
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hsplit : Splits (RingHom.id K) p
⊢ p = ↑C (leadingCoeff p) * Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p))
Theorem: Asymptotics.isBigOWith_neg_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def, norm_neg]
state_before: α : Type u_1
β : Type ?u.133553
E : Type ?u.133556
F : Type u_3
G : Type ?u.133562
E' : Type u_2
F' : Type ?u.133568
G' : Type ?u.133571
E'' : Type ?u.133574
F'' : Type ?u.133577
G'' : Type ?u.133580
R : Type ?u.133583
R' : Type ?u.133586
𝕜 : Type ?u.133589
𝕜' : Type ?u.133592
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 α
⊢ IsBigOWith c l (fun x => -f' x) g ↔ IsBigOWith c l f' g
Theorem: MeasureTheory.snorm'_eq_zero_of_ae_zero'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [snorm'_congr_ae hf_zero, snorm'_zero' hq0_ne hμ]
state_before: α : Type u_1
E : Type ?u.2313924
F : Type u_2
G : Type ?u.2313930
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
f : α → F
hf_zero : f =ᵐ[μ] 0
⊢ snorm' f q μ = 0
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_naturality
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: unfold mapMono
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
⊢ mapMono K i ≫ HomologicalComplex.Hom.f f (len Δ) = HomologicalComplex.Hom.f f (len Δ') ≫ mapMono K' i

tactic: split_ifs with h
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
⊢ (if h : Δ' = Δ then eqToHom (_ : HomologicalComplex.X K (len Δ') = HomologicalComplex.X K (len Δ))
      else if h : Isδ₀ i then HomologicalComplex.d K (len Δ') (len Δ) else 0) ≫
      HomologicalComplex.Hom.f f (len Δ) =
    HomologicalComplex.Hom.f f (len Δ') ≫
      if h : Δ' = Δ then eqToHom (_ : HomologicalComplex.X K' (len Δ') = HomologicalComplex.X K' (len Δ))
      else if h : Isδ₀ i then HomologicalComplex.d K' (len Δ') (len Δ) else 0

tactic: subst h
state_before: case inl
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : Δ' = Δ
⊢ eqToHom (_ : HomologicalComplex.X K (len Δ') = HomologicalComplex.X K (len Δ)) ≫ HomologicalComplex.Hom.f f (len Δ) =
    HomologicalComplex.Hom.f f (len Δ') ≫
      eqToHom (_ : HomologicalComplex.X K' (len Δ') = HomologicalComplex.X K' (len Δ))

tactic: simp only [id_comp, eqToHom_refl, comp_id]
state_before: case inl
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ' Δ'' : SimplexCategory
i : Δ' ⟶ Δ'
inst✝ : Mono i
⊢ eqToHom (_ : HomologicalComplex.X K (len Δ') = HomologicalComplex.X K (len Δ')) ≫
      HomologicalComplex.Hom.f f (len Δ') =
    HomologicalComplex.Hom.f f (len Δ') ≫
      eqToHom (_ : HomologicalComplex.X K' (len Δ') = HomologicalComplex.X K' (len Δ'))

tactic: rw [HomologicalComplex.Hom.comm]
state_before: case inr.inl
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : ¬Δ' = Δ
h✝ : Isδ₀ i
⊢ HomologicalComplex.d K (len Δ') (len Δ) ≫ HomologicalComplex.Hom.f f (len Δ) =
    HomologicalComplex.Hom.f f (len Δ') ≫ HomologicalComplex.d K' (len Δ') (len Δ)

tactic: rw [zero_comp, comp_zero]
state_before: case inr.inr
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : ¬Δ' = Δ
h✝ : ¬Isδ₀ i
⊢ 0 ≫ HomologicalComplex.Hom.f f (len Δ) = HomologicalComplex.Hom.f f (len Δ') ≫ 0
Theorem: TypeVec.id_eq_nilFun
File: Mathlib/Data/TypeVec.lean

tactic: ext x
state_before: n : ℕ
α : TypeVec 0
⊢ id = nilFun

tactic: cases x
state_before: case a.h
n : ℕ
α : TypeVec 0
x : Fin2 0
x✝ : α x
⊢ id x x✝ = nilFun x x✝
Theorem: Function.Periodic.add_const
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [add_right_comm] using h (x + a)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.84885
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (x + a)) (x + c) = (fun x => f (x + a)) x
Theorem: Nat.lt_mul_div_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_comm, ← Nat.div_lt_iff_lt_mul' n0]
state_before: m✝ n✝ k m n : ℕ
n0 : 0 < n
⊢ m < n * (m / n + 1)

tactic: exact lt_succ_self _
state_before: m✝ n✝ k m n : ℕ
n0 : 0 < n
⊢ m / n < m / n + 1
Theorem: SimpleGraph.not_isUniform_iff
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: unfold IsUniform
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ ¬IsUniform G ε s t ↔
    ∃ s',
      s' ⊆ s ∧
        ∃ t',
          t' ⊆ t ∧
            ↑(card s) * ε ≤ ↑(card s') ∧
              ↑(card t) * ε ≤ ↑(card t') ∧ ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))

tactic: simp only [not_forall, not_lt, exists_prop, exists_and_left, Rat.cast_abs, Rat.cast_sub]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ (¬∀ ⦃s' : Finset α⦄,
        s' ⊆ s →
          ∀ ⦃t' : Finset α⦄,
            t' ⊆ t →
              ↑(card s) * ε ≤ ↑(card s') →
                ↑(card t) * ε ≤ ↑(card t') → abs (↑(edgeDensity G s' t') - ↑(edgeDensity G s t)) < ε) ↔
    ∃ s',
      s' ⊆ s ∧
        ∃ t',
          t' ⊆ t ∧
            ↑(card s) * ε ≤ ↑(card s') ∧
              ↑(card t) * ε ≤ ↑(card t') ∧ ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))
Theorem: Multiset.card_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [← cons_zero, card_zero, eq_self_iff_true, zero_add, card_cons]
state_before: α : Type u_1
β : Type ?u.58836
γ : Type ?u.58839
a : α
⊢ ↑card {a} = 1
Theorem: FirstOrder.Language.Structure.CG.range
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [Hom.range_eq_map]
state_before: L : Language
M : Type u_4
inst✝¹ : Structure L M
N : Type u_1
inst✝ : Structure L N
h : CG L M
f : M →[L] N
⊢ Substructure.CG (Hom.range f)

tactic: exact (cg_def.1 h).map f
state_before: L : Language
M : Type u_4
inst✝¹ : Structure L M
N : Type u_1
inst✝ : Structure L N
h : CG L M
f : M →[L] N
⊢ Substructure.CG (map f ⊤)
Theorem: finprod_mem_eq_finite_toFinset_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [hs.coe_toFinset]
state_before: α : Type u_1
β : Type ?u.201940
ι : Type ?u.201943
G : Type ?u.201946
M : Type u_2
N : Type ?u.201952
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hs : Set.Finite s
⊢ (s ∩ mulSupport fun i => f i) = ↑(Finite.toFinset hs) ∩ mulSupport fun i => f i
Theorem: Rack.self_invAct_invAct_eq
File: Mathlib/Algebra/Quandle.lean

tactic: have h := @self_act_act_eq _ _ (op x) (op y)
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y

tactic: simpa using h
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : (op x ◃ op x) ◃ op y = op x ◃ op y
⊢ (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y
Theorem: Real.tan_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [← not_iff_not, not_exists, ← Ne, tan_ne_zero_iff]
state_before: θ : ℝ
⊢ tan θ = 0 ↔ ∃ k, θ = ↑k * π / 2
Theorem: SimpleGraph.dart_card_eq_twice_card_edges
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

tactic: rw [← card_univ]
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
⊢ Fintype.card (Dart G) = 2 * card (edgeFinset G)

tactic: rw [@card_eq_sum_card_fiberwise _ _ _ Dart.edge _ G.edgeFinset fun d _h =>
    by rw [mem_edgeFinset]; apply Dart.edge_mem]
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
⊢ card univ = 2 * card (edgeFinset G)

tactic: rw [← mul_comm, sum_const_nat]
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
⊢ ∑ a in edgeFinset G, card (filter (fun x => Dart.edge x = a) univ) = 2 * card (edgeFinset G)

tactic: intro e h
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
⊢ ∀ (x : Sym2 V), x ∈ edgeFinset G → card (filter (fun x_1 => Dart.edge x_1 = x) univ) = 2

tactic: apply G.dart_edge_fiber_card e
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
e : Sym2 V
h : e ∈ edgeFinset G
⊢ card (filter (fun x => Dart.edge x = e) univ) = 2

tactic: rwa [← mem_edgeFinset]
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
e : Sym2 V
h : e ∈ edgeFinset G
⊢ e ∈ edgeSet G

tactic: rw [mem_edgeFinset]
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
d : Dart G
_h : d ∈ univ
⊢ Dart.edge d ∈ edgeFinset G

tactic: apply Dart.edge_mem
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
d : Dart G
_h : d ∈ univ
⊢ Dart.edge d ∈ edgeSet G
Theorem: StieltjesFunction.measure_Ico
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: rcases le_or_lt b a with (hab | hab)
state_before: f : StieltjesFunction
a b : ℝ
⊢ ↑↑(StieltjesFunction.measure f) (Ico a b) = ofReal (leftLim (↑f) b - leftLim (↑f) a)

tactic: simp only [hab, measure_empty, Ico_eq_empty, not_lt]
state_before: case inl
f : StieltjesFunction
a b : ℝ
hab : b ≤ a
⊢ ↑↑(StieltjesFunction.measure f) (Ico a b) = ofReal (leftLim (↑f) b - leftLim (↑f) a)

tactic: symm
state_before: case inl
f : StieltjesFunction
a b : ℝ
hab : b ≤ a
⊢ 0 = ofReal (leftLim (↑f) b - leftLim (↑f) a)

tactic: simp [ENNReal.ofReal_eq_zero, f.mono.leftLim hab]
state_before: case inl
f : StieltjesFunction
a b : ℝ
hab : b ≤ a
⊢ ofReal (leftLim (↑f) b - leftLim (↑f) a) = 0

tactic: have A : Disjoint {a} (Ioo a b) := by simp
state_before: case inr
f : StieltjesFunction
a b : ℝ
hab : a < b
⊢ ↑↑(StieltjesFunction.measure f) (Ico a b) = ofReal (leftLim (↑f) b - leftLim (↑f) a)

tactic: simp [← Icc_union_Ioo_eq_Ico le_rfl hab, -singleton_union, hab.ne, f.mono.leftLim_le,
  measure_union A measurableSet_Ioo, f.mono.le_leftLim hab, ← ENNReal.ofReal_add]
state_before: case inr
f : StieltjesFunction
a b : ℝ
hab : a < b
A : Disjoint {a} (Ioo a b)
⊢ ↑↑(StieltjesFunction.measure f) (Ico a b) = ofReal (leftLim (↑f) b - leftLim (↑f) a)

tactic: simp
state_before: f : StieltjesFunction
a b : ℝ
hab : a < b
⊢ Disjoint {a} (Ioo a b)
Theorem: Real.tendsto_abs_tan_of_cos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: have hx : Complex.cos x = 0 := by exact_mod_cast hx
state_before: x : ℝ
hx : cos x = 0
⊢ Tendsto (fun x => abs (tan x)) (𝓝[{x}ᶜ] x) atTop

tactic: simp only [← Complex.abs_ofReal, Complex.ofReal_tan]
state_before: x : ℝ
hx✝ : cos x = 0
hx : Complex.cos ↑x = 0
⊢ Tendsto (fun x => abs (tan x)) (𝓝[{x}ᶜ] x) atTop

tactic: refine' (Complex.tendsto_abs_tan_of_cos_eq_zero hx).comp _
state_before: x : ℝ
hx✝ : cos x = 0
hx : Complex.cos ↑x = 0
⊢ Tendsto (fun x => ↑Complex.abs (Complex.tan ↑x)) (𝓝[{x}ᶜ] x) atTop

tactic: refine' Tendsto.inf Complex.continuous_ofReal.continuousAt _
state_before: x : ℝ
hx✝ : cos x = 0
hx : Complex.cos ↑x = 0
⊢ Tendsto (fun x => ↑x) (𝓝[{x}ᶜ] x) (𝓝[{↑x}ᶜ] ↑x)

tactic: exact tendsto_principal_principal.2 fun y => mt Complex.ofReal_inj.1
state_before: x : ℝ
hx✝ : cos x = 0
hx : Complex.cos ↑x = 0
⊢ Tendsto (fun x => ↑x) (𝓟 ({x}ᶜ)) (𝓟 ({↑x}ᶜ))

tactic: exact_mod_cast hx
state_before: x : ℝ
hx : cos x = 0
⊢ Complex.cos ↑x = 0
Theorem: InitialSeg.eq
File: Mathlib/Order/InitialSeg.lean

tactic: rw [Subsingleton.elim f g]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.18205
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder β s
f g : r ≼i s
a : α
⊢ ↑f a = ↑g a
Theorem: ProbabilityTheory.indepSets_singleton_iff
File: Mathlib/Probability/Independence/Basic.lean

tactic: rwa [Set.mem_singleton_iff.mp hs1, Set.mem_singleton_iff.mp ht1]
state_before: Ω : Type u_1
ι : Type ?u.1351878
inst✝ : MeasurableSpace Ω
s t : Set Ω
μ : MeasureTheory.Measure Ω
h : ↑↑μ (s ∩ t) = ↑↑μ s * ↑↑μ t
s1 t1 : Set Ω
hs1 : s1 ∈ {s}
ht1 : t1 ∈ {t}
⊢ ↑↑μ (s1 ∩ t1) = ↑↑μ s1 * ↑↑μ t1
Theorem: round_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [←round_add_int a 1, cast_one]
state_before: F : Type ?u.254868
α : Type u_1
β : Type ?u.254874
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
a : α
⊢ round (a + 1) = round a + 1
Theorem: Polynomial.natDegree_toSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp [natDegree]
state_before: R : Type u
S : Type ?u.92445
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ natDegree (toSubring p T hp) = natDegree p
Theorem: Set.image_preimage_eq_of_subset
File: Mathlib/Data/Set/Image.lean

tactic: rw [image_preimage_eq_inter_range, inter_eq_self_of_subset_left hs]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.74448
ι : Sort ?u.74451
ι' : Sort ?u.74454
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
hs : s ⊆ range f
⊢ f '' (f ⁻¹' s) = s
Theorem: toMatrix_distrib_mul_action_toLinearMap
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2925604
m : Type ?u.2925607
n : Type u_2
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_3
M₂ : Type ?u.2925631
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2926133
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
x : R
⊢ ↑(toMatrix v₁ v₁) (DistribMulAction.toLinearMap R M₁ x) = Matrix.diagonal fun x_1 => x

tactic: rw [LinearMap.toMatrix_apply, DistribMulAction.toLinearMap_apply, LinearEquiv.map_smul,
  Basis.repr_self, Finsupp.smul_single_one, Finsupp.single_eq_pi_single, Matrix.diagonal_apply,
  Pi.single_apply]
state_before: case a.h
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2925604
m : Type ?u.2925607
n : Type u_2
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_3
M₂ : Type ?u.2925631
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2926133
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
x : R
i✝ x✝ : n
⊢ ↑(toMatrix v₁ v₁) (DistribMulAction.toLinearMap R M₁ x) i✝ x✝ = Matrix.diagonal (fun x_1 => x) i✝ x✝
Theorem: div_eq_mul_one_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, one_div]
state_before: α : Type ?u.20005
β : Type ?u.20008
G : Type u_1
inst✝ : DivInvMonoid G
a✝ b✝ c a b : G
⊢ a / b = a * (1 / b)
Theorem: measurableSet_inr_image
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: simp [measurableSet_sum_iff, Sum.inr_injective.preimage_image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.377196
δ : Type ?u.377199
δ' : Type ?u.377202
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set β
⊢ MeasurableSet (Sum.inr '' s) ↔ MeasurableSet s
Theorem: Order.IsSuccLimit.succ_lt
File: Mathlib/Order/SuccPred/Limit.lean

tactic: by_cases h : IsMax a
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort ?u.5191
hb : IsSuccLimit b
ha : a < b
⊢ succ a < b

tactic: rwa [h.succ_eq]
state_before: case pos
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort ?u.5191
hb : IsSuccLimit b
ha : a < b
h : IsMax a
⊢ succ a < b

tactic: rw [lt_iff_le_and_ne, succ_le_iff_of_not_isMax h]
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort ?u.5191
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ succ a < b

tactic: refine' ⟨ha, fun hab => _⟩
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort ?u.5191
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ a < b ∧ succ a ≠ b

tactic: subst hab
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort ?u.5191
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
hab : succ a = b
⊢ False

tactic: exact (h hb.isMax).elim
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
C : α → Sort ?u.5191
h : ¬IsMax a
hb : IsSuccLimit (succ a)
ha : a < succ a
⊢ False
Theorem: exists_pos_left_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

tactic: refine' ⟨fun h => _, fun h => h.exists_pos_left hx hy⟩
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • x = y) ↔ SameRay R x y

tactic: rcases h with ⟨r, hr, rfl⟩
state_before: R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
h : ∃ r, 0 < r ∧ r • x = y
⊢ SameRay R x y

tactic: exact SameRay.sameRay_pos_smul_right x hr
state_before: case intro.intro
R : Type u_2
inst✝² : LinearOrderedField R
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hx : x ≠ 0
r : R
hr : 0 < r
hy : r • x ≠ 0
⊢ SameRay R x (r • x)