tasksource/leandojo huggingface dataset:
Theorem: Nat.digits_len
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' n using Nat.strong_induction_on with n IH
state_before: n✝ b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ List.length (digits b n) = log b n + 1

tactic: rw [digits_eq_cons_digits_div hb hn, List.length]
state_before: case h
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
⊢ List.length (digits b n) = log b n + 1

tactic: by_cases h : n / b = 0
state_before: case h
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
⊢ List.length (digits b (n / b)) + 1 = log b n + 1

tactic: have hb0 : b ≠ 0 := (Nat.succ_le_iff.1 hb).ne_bot
state_before: case pos
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : n / b = 0
⊢ List.length (digits b (n / b)) + 1 = log b n + 1

tactic: simp [h, log_eq_zero_iff, ← Nat.div_eq_zero_iff hb0.bot_lt]
state_before: case pos
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : n / b = 0
hb0 : b ≠ 0
⊢ List.length (digits b (n / b)) + 1 = log b n + 1

tactic: have : n / b < n := div_lt_self (Nat.pos_of_ne_zero hn) hb
state_before: case neg
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : ¬n / b = 0
⊢ List.length (digits b (n / b)) + 1 = log b n + 1

tactic: rw [IH _ this h, log_div_base, tsub_add_cancel_of_le]
state_before: case neg
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : ¬n / b = 0
this : n / b < n
⊢ List.length (digits b (n / b)) + 1 = log b n + 1

tactic: refine' Nat.succ_le_of_lt (log_pos hb _)
state_before: case neg
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : ¬n / b = 0
this : n / b < n
⊢ 1 ≤ log b n

tactic: contrapose! h
state_before: case neg
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
h : ¬n / b = 0
this : n / b < n
⊢ b ≤ n

tactic: exact div_eq_of_lt h
state_before: case neg
n✝¹ b n✝ : ℕ
hb : 1 < b
hn✝ : n✝ ≠ 0
n : ℕ
IH : ∀ (m : ℕ), m < n → m ≠ 0 → List.length (digits b m) = log b m + 1
hn : n ≠ 0
this : n / b < n
h : n < b
⊢ n / b = 0
Theorem: multiplicity.Int.natAbs
File: Mathlib/RingTheory/Multiplicity.lean

tactic: cases' Int.natAbs_eq b with h h <;> conv_rhs => rw [h]
state_before: α : Type ?u.1342344
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
⊢ multiplicity a (_root_.Int.natAbs b) = multiplicity (↑a) b

tactic: rw [Int.coe_nat_multiplicity]
state_before: case inl
α : Type ?u.1342344
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = ↑(_root_.Int.natAbs b)
⊢ multiplicity a (_root_.Int.natAbs b) = multiplicity ↑a ↑(_root_.Int.natAbs b)

tactic: rw [multiplicity.neg, Int.coe_nat_multiplicity]
state_before: case inr
α : Type ?u.1342344
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = -↑(_root_.Int.natAbs b)
⊢ multiplicity a (_root_.Int.natAbs b) = multiplicity (↑a) (-↑(_root_.Int.natAbs b))
Theorem: MeasureTheory.lintegral_countable'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: conv_lhs => rw [← sum_smul_dirac μ, lintegral_sum_measure]
state_before: α : Type u_1
β : Type ?u.1727935
γ : Type ?u.1727938
δ : Type ?u.1727941
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α), f a ∂μ) = ∑' (a : α), f a * ↑↑μ {a}

tactic: congr 1 with a : 1
state_before: α : Type u_1
β : Type ?u.1727935
γ : Type ?u.1727938
δ : Type ?u.1727941
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
f : α → ℝ≥0∞
⊢ (∑' (i : α), ∫⁻ (a : α), f a ∂↑↑μ {i} • dirac i) = ∑' (a : α), f a * ↑↑μ {a}

tactic: rw [lintegral_smul_measure, lintegral_dirac, mul_comm]
state_before: case e_f.h
α : Type u_1
β : Type ?u.1727935
γ : Type ?u.1727938
δ : Type ?u.1727941
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : Countable α
inst✝ : MeasurableSingletonClass α
f : α → ℝ≥0∞
a : α
⊢ (∫⁻ (a : α), f a ∂↑↑μ {a} • dirac a) = f a * ↑↑μ {a}
Theorem: solvable_of_ker_le_range
File: Mathlib/GroupTheory/Solvable.lean

tactic: obtain ⟨n, hn⟩ := id hG''
state_before: G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
⊢ IsSolvable G

tactic: obtain ⟨m, hm⟩ := id hG'
state_before: case mk.intro
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
⊢ IsSolvable G

tactic: refine' ⟨⟨n + m, le_bot_iff.mp (map_bot f ▸ hm ▸ _)⟩⟩
state_before: case mk.intro.mk.intro
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
m : ℕ
hm : derivedSeries G' m = ⊥
⊢ IsSolvable G

tactic: clear hm
state_before: case mk.intro.mk.intro
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
m : ℕ
hm : derivedSeries G' m = ⊥
⊢ derivedSeries G (n + m) ≤ map f (derivedSeries G' m)

tactic: induction' m with m hm
state_before: case mk.intro.mk.intro
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
m : ℕ
⊢ derivedSeries G (n + m) ≤ map f (derivedSeries G' m)

tactic: exact f.range_eq_map ▸ ((derivedSeries G n).map_eq_bot_iff.mp
  (le_bot_iff.mp ((map_derivedSeries_le_derivedSeries g n).trans hn.le))).trans hfg
state_before: case mk.intro.mk.intro.zero
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
⊢ derivedSeries G (n + Nat.zero) ≤ map f (derivedSeries G' Nat.zero)

tactic: exact commutator_le_map_commutator hm hm
state_before: case mk.intro.mk.intro.succ
G : Type u_3
G'✝ : Type ?u.45008
inst✝³ : Group G
inst✝² : Group G'✝
f✝ : G →* G'✝
G' : Type u_1
G'' : Type u_2
inst✝¹ : Group G'
inst✝ : Group G''
f : G' →* G
g : G →* G''
hfg : MonoidHom.ker g ≤ MonoidHom.range f
hG' : IsSolvable G'
hG'' : IsSolvable G''
n : ℕ
hn : derivedSeries G'' n = ⊥
m : ℕ
hm : derivedSeries G (n + m) ≤ map f (derivedSeries G' m)
⊢ derivedSeries G (n + Nat.succ m) ≤ map f (derivedSeries G' (Nat.succ m))
Theorem: exp_zero
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: simp_rw [exp_eq_tsum, ← expSeries_apply_eq, expSeries_apply_zero, tsum_pi_single]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
⊢ exp 𝕂 0 = 1
Theorem: Disjoint.symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type ?u.76942
α : Type u_1
β : Type ?u.76948
π : ι → Type ?u.76953
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint (a ∆ b) c

tactic: exact (ha.sup_left hb).disjoint_sdiff_left
state_before: ι : Type ?u.76942
α : Type u_1
β : Type ?u.76948
π : ι → Type ?u.76953
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : Disjoint a c
hb : Disjoint b c
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) c
Theorem: PiNat.cylinder_eq_cylinder_of_le_firstDiff
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rw [← mem_cylinder_iff_eq]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hn : n ≤ firstDiff x y
⊢ cylinder x n = cylinder y n

tactic: intro i hi
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hn : n ≤ firstDiff x y
⊢ x ∈ cylinder y n

tactic: exact apply_eq_of_lt_firstDiff (hi.trans_le hn)
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hn : n ≤ firstDiff x y
i : ℕ
hi : i < n
⊢ x i = y i
Theorem: TopCat.Presheaf.stalk_hom_ext
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: induction' U using Opposite.rec with U
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : (OpenNhds x)ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F) U ≫ f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F) U ≫ f₂

tactic: cases' U with U hxU
state_before: case mk
C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : OpenNhds x
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F)
        { unop := U } ≫
      f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F)
        { unop := U } ≫
      f₂

tactic: exact ih U hxU
state_before: case mk.mk
C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : Opens ↑X
hxU : x ∈ U
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F)
        { unop := { obj := U, property := hxU } } ≫
      f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F)
        { unop := { obj := U, property := hxU } } ≫
      f₂
Theorem: Filter.tendsto_principal_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [tendsto_principal, eventually_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.317533
ι : Sort x
f : α → β
s : Set α
t : Set β
⊢ Tendsto f (𝓟 s) (𝓟 t) ↔ ∀ (a : α), a ∈ s → f a ∈ t
Theorem: ENNReal.inv_pow
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [pow_zero, inv_one]
state_before: α : Type ?u.223062
β : Type ?u.223065
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ : ℝ≥0∞
⊢ (x✝ ^ 0)⁻¹ = x✝⁻¹ ^ 0

tactic: simp [top_pow]
state_before: α : Type ?u.223062
β : Type ?u.223065
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ (⊤ ^ (n + 1))⁻¹ = ⊤⁻¹ ^ (n + 1)

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: α : Type ?u.223062
β : Type ?u.223065
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)

tactic: simp [top_pow]
state_before: case inl
α : Type ?u.223062
β : Type ?u.223065
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ (↑0 ^ (n + 1))⁻¹ = (↑0)⁻¹ ^ (n + 1)

tactic: have := pow_ne_zero (n + 1) ha
state_before: case inr
α : Type ?u.223062
β : Type ?u.223065
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)

tactic: norm_cast
state_before: case inr
α : Type ?u.223062
β : Type ?u.223065
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (↑a ^ (n + 1))⁻¹ = (↑a)⁻¹ ^ (n + 1)

tactic: rw [inv_pow]
state_before: case inr
α : Type ?u.223062
β : Type ?u.223065
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
n : ℕ
ha : a ≠ 0
this : a ^ (n + 1) ≠ 0
⊢ (a ^ (n + 1))⁻¹ = a⁻¹ ^ (n + 1)
Theorem: Rat.mul_inv_cancel
File: Mathlib/Data/Rat/Defs.lean

tactic: have n0 : n ≠ 0 := mt (by rintro rfl; simp) a0
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
a0 : n /. ↑d ≠ 0
⊢ n /. ↑d * (n /. ↑d)⁻¹ = 1

tactic: simpa [h, n0, mul_comm] using @divInt_mul_right 1 1 (n * d) (by simp [h, n0])
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
a0 : n /. ↑d ≠ 0
n0 : n ≠ 0
⊢ n /. ↑d * (n /. ↑d)⁻¹ = 1

tactic: rintro rfl
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
a0 : n /. ↑d ≠ 0
⊢ n = 0 → n /. ↑d = 0

tactic: simp
state_before: a b c : ℚ
d : ℕ
h : d ≠ 0
a0 : 0 /. ↑d ≠ 0
⊢ 0 /. ↑d = 0

tactic: simp [h, n0]
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
a0 : n /. ↑d ≠ 0
n0 : n ≠ 0
⊢ n * ↑d ≠ 0
Theorem: Complex.frontier_setOf_re_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Iic] using frontier_preimage_re (Iic a)
state_before: a : ℝ
⊢ frontier {z | z.re ≤ a} = {z | z.re = a}
Theorem: ENNReal.rpow_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [lt_irrefl]
state_before: case some
val✝ : ℝ≥0
⊢ (if val✝ = 0 ∧ 0 < 0 then ⊤ else ↑(NNReal.rpow val✝ 0)) = 1
Theorem: LinearMap.toMatrix_id_eq_basis_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: haveI := Classical.decEq ι'
state_before: ι : Type u_1
ι' : Type u_2
κ : Type ?u.583643
κ' : Type ?u.583646
R : Type u_3
M : Type u_4
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type ?u.583839
M₂ : Type ?u.583842
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type ?u.584587
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Fintype κ
inst✝² : Fintype κ'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
⊢ ↑(toMatrix b b') id = Basis.toMatrix b' ↑b

tactic: rw [← @basis_toMatrix_mul_linearMap_toMatrix _ _ ι, toMatrix_id, Matrix.mul_one]
state_before: ι : Type u_1
ι' : Type u_2
κ : Type ?u.583643
κ' : Type ?u.583646
R : Type u_3
M : Type u_4
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type ?u.583839
M₂ : Type ?u.583842
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type ?u.584587
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Fintype κ
inst✝² : Fintype κ'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
this : DecidableEq ι'
⊢ ↑(toMatrix b b') id = Basis.toMatrix b' ↑b
Theorem: Rat.preimage_cast_Iic
File: Mathlib/Data/Rat/Cast.lean

tactic: ext x
state_before: F : Type ?u.77511
ι : Type ?u.77514
α : Type ?u.77517
β : Type ?u.77520
K : Type u_1
inst✝ : LinearOrderedField K
a : ℚ
⊢ Rat.cast ⁻¹' Iic ↑a = Iic a

tactic: simp
state_before: case h
F : Type ?u.77511
ι : Type ?u.77514
α : Type ?u.77517
β : Type ?u.77520
K : Type u_1
inst✝ : LinearOrderedField K
a x : ℚ
⊢ x ∈ Rat.cast ⁻¹' Iic ↑a ↔ x ∈ Iic a
Theorem: List.pairwise_pwFilter
File: Mathlib/Data/List/Pairwise.lean

tactic: by_cases h : ∀ y ∈ pwFilter R l, R x y
state_before: α : Type u_1
β : Type ?u.51574
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
⊢ Pairwise R (pwFilter R (x :: l))

tactic: rw [pwFilter_cons_of_pos h]
state_before: case pos
α : Type u_1
β : Type ?u.51574
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ∀ (y : α), y ∈ pwFilter R l → R x y
⊢ Pairwise R (pwFilter R (x :: l))

tactic: exact pairwise_cons.2 ⟨h, pairwise_pwFilter l⟩
state_before: case pos
α : Type u_1
β : Type ?u.51574
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ∀ (y : α), y ∈ pwFilter R l → R x y
⊢ Pairwise R (x :: pwFilter R l)

tactic: rw [pwFilter_cons_of_neg h]
state_before: case neg
α : Type u_1
β : Type ?u.51574
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ¬∀ (y : α), y ∈ pwFilter R l → R x y
⊢ Pairwise R (pwFilter R (x :: l))

tactic: exact pairwise_pwFilter l
state_before: case neg
α : Type u_1
β : Type ?u.51574
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
x : α
l : List α
h : ¬∀ (y : α), y ∈ pwFilter R l → R x y
⊢ Pairwise R (pwFilter R l)
Theorem: Nat.div_eq_of_lt_le
File: Std/Data/Nat/Lemmas.lean

tactic: rw [hn, Nat.mul_zero] at hi lo
state_before: k n m : Nat
lo : k * n ≤ m
hi : m < succ k * n
hn : n = 0
⊢ False

tactic: exact absurd lo (Nat.not_le_of_gt hi)
state_before: k n m : Nat
lo : 0 ≤ m
hi : m < 0
hn : n = 0
⊢ False
Theorem: polynomialFunctions_closure_eq_top'
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

tactic: apply eq_top_iff.mpr
state_before: ⊢ Subalgebra.topologicalClosure (polynomialFunctions I) = ⊤

tactic: rintro f -
state_before: ⊢ ⊤ ≤ Subalgebra.topologicalClosure (polynomialFunctions I)

tactic: refine' Filter.Frequently.mem_closure _
state_before: f : C(↑I, ℝ)
⊢ f ∈ Subalgebra.topologicalClosure (polynomialFunctions I)

tactic: refine' Filter.Tendsto.frequently (bernsteinApproximation_uniform f) _
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : C(↑I, ℝ)) in nhds f, x ∈ ↑(polynomialFunctions I)

tactic: apply frequently_of_forall
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : ℕ) in atTop, bernsteinApproximation x f ∈ ↑(polynomialFunctions I)

tactic: intro n
state_before: case h
f : C(↑I, ℝ)
⊢ ∀ (x : ℕ), bernsteinApproximation x f ∈ ↑(polynomialFunctions I)

tactic: simp only [SetLike.mem_coe]
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ ↑(polynomialFunctions I)

tactic: apply Subalgebra.sum_mem
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ polynomialFunctions I

tactic: rintro n -
state_before: case h.h
f : C(↑I, ℝ)
n : ℕ
⊢ ∀ (x : Fin (n + 1)), x ∈ Finset.univ → ↑f (bernstein.z x) • bernstein n ↑x ∈ polynomialFunctions I

tactic: apply Subalgebra.smul_mem
state_before: case h.h
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ ↑f (bernstein.z n) • bernstein n✝ ↑n ∈ polynomialFunctions I

tactic: dsimp [bernstein, polynomialFunctions]
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ bernstein n✝ ↑n ∈ polynomialFunctions I

tactic: simp
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ Polynomial.toContinuousMapOn (bernsteinPolynomial ℝ n✝ ↑n) I ∈ Subalgebra.map (Polynomial.toContinuousMapOnAlgHom I) ⊤
Theorem: Ideal.Factors.finrank_pow_ramificationIdx
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rw [finrank_prime_pow_ramificationIdx, inertiaDeg_algebraMap]
state_before: R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : Algebra R S
inst✝ : IsMaximal p
P : { x // x ∈ Multiset.toFinset (factors (map (algebraMap R S) p)) }
⊢ finrank (R ⧸ p) (S ⧸ ↑P ^ ramificationIdx (algebraMap R S) p ↑P) =
    ramificationIdx (algebraMap R S) p ↑P * inertiaDeg (algebraMap R S) p ↑P

tactic: exacts [NeZero.ne _, Factors.ne_bot p P]
state_before: case he
R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : Algebra R S
inst✝ : IsMaximal p
P : { x // x ∈ Multiset.toFinset (factors (map (algebraMap R S) p)) }
⊢ ramificationIdx (algebraMap R S) p ↑P ≠ 0

case hP0
R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : Algebra R S
inst✝ : IsMaximal p
P : { x // x ∈ Multiset.toFinset (factors (map (algebraMap R S) p)) }
⊢ ↑P ≠ ⊥

case he
R : Type u
inst✝⁵ : CommRing R
S : Type v
inst✝⁴ : CommRing S
f : R →+* S
p : Ideal R
P✝ : Ideal S
inst✝³ : IsDomain S
inst✝² : IsDedekindDomain S
inst✝¹ : Algebra R S
inst✝ : IsMaximal p
P : { x // x ∈ Multiset.toFinset (factors (map (algebraMap R S) p)) }
⊢ ramificationIdx (algebraMap R S) p ↑P ≠ 0
Theorem: Complex.hasStrictDerivAt_cpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa only [MulZeroClass.mul_zero, add_zero, mul_one] using
  (hasStrictDerivAt_id x).cpow (hasStrictDerivAt_const x c) h
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x c : ℂ
h : 0 < x.re ∨ x.im ≠ 0
⊢ HasStrictDerivAt (fun z => z ^ c) (c * x ^ (c - 1)) x
Theorem: Submodule.closedComplemented_top
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝⁶ : Ring R
M : Type u_2
inst✝⁵ : TopologicalSpace M
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M₂ : Type ?u.2068318
inst✝² : TopologicalSpace M₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
x : { x // x ∈ ⊤ }
⊢ ↑(↑(codRestrict (ContinuousLinearMap.id R M) ⊤ (_ : M → True)) ↑x) = ↑x
Theorem: EMetric.ball_prod_same
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp [Prod.edist_eq]
state_before: α : Type u
β : Type v
X : Type ?u.217515
inst✝¹ : PseudoEMetricSpace α
x✝ y✝ z✝ : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
inst✝ : PseudoEMetricSpace β
x : α
y : β
r : ℝ≥0∞
z : α × β
⊢ z ∈ ball x r ×ˢ ball y r ↔ z ∈ ball (x, y) r
Theorem: AntilipschitzWith.le_mul_norm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [← dist_eq_norm_div, hf.le_mul_dist x y]
state_before: 𝓕 : Type ?u.1214055
𝕜 : Type ?u.1214058
α : Type ?u.1214061
ι : Type ?u.1214064
κ : Type ?u.1214067
E : Type u_1
F : Type u_2
G : Type ?u.1214076
inst✝² : SeminormedCommGroup E
inst✝¹ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f✝ g : α → E
f : E → F
hf : AntilipschitzWith K f
x y : E
⊢ ‖x / y‖ ≤ ↑K * ‖f x / f y‖
Theorem: CategoryTheory.Limits.colimit.ι_map
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
j : J
⊢ ι F j ≫ colim.map α = α.app j ≫ ι G j
Theorem: CategoryTheory.Limits.IsInitial.strict_hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

tactic: haveI := hI.isIso_to f
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
⊢ f = g

tactic: haveI := hI.isIso_to g
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this : IsIso f
⊢ f = g

tactic: exact eq_of_inv_eq_inv (hI.hom_ext (inv f) (inv g))
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this✝ : IsIso f
this : IsIso g
⊢ f = g
Theorem: Multiset.inl_mem_disjSum
File: Mathlib/Data/Multiset/Sum.lean

tactic: rw [mem_disjSum, or_iff_left]
state_before: α : Type u_2
β : Type u_1
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
⊢ inl a ∈ disjSum s t ↔ a ∈ s

tactic: simp only [inl.injEq, exists_eq_right]
state_before: α : Type u_2
β : Type u_1
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
⊢ (∃ a_1, a_1 ∈ s ∧ inl a_1 = inl a) ↔ a ∈ s

α : Type u_2
β : Type u_1
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
⊢ ¬∃ b, b ∈ t ∧ inr b = inl a

tactic: rintro ⟨b, _, hb⟩
state_before: α : Type u_2
β : Type u_1
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
⊢ ¬∃ b, b ∈ t ∧ inr b = inl a

tactic: exact inr_ne_inl hb
state_before: case intro.intro
α : Type u_2
β : Type u_1
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b✝ : β
x : α ⊕ β
b : β
left✝ : b ∈ t
hb : inr b = inl a
⊢ False