tasksource/leandojo huggingface dataset:
Theorem: EMetric.uniformInducing_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [subset_def, Prod.forall]
state_before: α : Type u
β : Type v
X : Type ?u.25437
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ≥0∞), 0 < i' → ∃ i, 0 < i ∧ Prod.map f f ⁻¹' {p | edist p.fst p.snd < i} ⊆ {p | edist p.fst p.snd < i'}) ↔
    ∀ (δ : ℝ≥0∞), δ > 0 → ∃ ε, ε > 0 ∧ ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ

tactic: rfl
state_before: α : Type u
β : Type v
X : Type ?u.25437
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ≥0∞),
      0 < i' →
        ∃ i,
          0 < i ∧
            ∀ (a b : α),
              (a, b) ∈ Prod.map f f ⁻¹' {p | edist p.fst p.snd < i} → (a, b) ∈ {p | edist p.fst p.snd < i'}) ↔
    ∀ (δ : ℝ≥0∞), δ > 0 → ∃ ε, ε > 0 ∧ ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ
Theorem: ENNReal.div_eq_inv_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [div_eq_mul_inv, mul_comm]
state_before: α : Type ?u.213054
β : Type ?u.213057
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / b = b⁻¹ * a
Theorem: lt_sup_iff
File: Mathlib/Order/Lattice.lean

tactic: exact ⟨fun h =>
  (le_total c b).imp
    (fun bc => by rwa [sup_eq_left.2 bc] at h)
    (fun bc => by rwa [sup_eq_right.2 bc] at h),
  fun h => h.elim lt_sup_of_lt_left lt_sup_of_lt_right⟩
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
⊢ a < b ⊔ c ↔ a < b ∨ a < c

tactic: rwa [sup_eq_left.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a < b ⊔ c
bc : c ≤ b
⊢ a < b

tactic: rwa [sup_eq_right.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a < b ⊔ c
bc : b ≤ c
⊢ a < c
Theorem: nhdsSet_union
File: Mathlib/Topology/NhdsSet.lean

tactic: simp only [nhdsSet, image_union, sSup_union]
state_before: α : Type u_1
β : Type ?u.13421
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s₁ s₂ t₁ t₂ : Set α
x : α
s t : Set α
⊢ 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t
Theorem: Int.log_natCast
File: Mathlib/Data/Int/Log.lean

tactic: cases n
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b n : ℕ
⊢ log b ↑n = ↑(Nat.log b n)

tactic: simp [log_of_right_le_one]
state_before: case zero
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
⊢ log b ↑Nat.zero = ↑(Nat.log b Nat.zero)

tactic: rw [log_of_one_le_right, Nat.floor_coe]
state_before: case succ
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b n✝ : ℕ
⊢ log b ↑(Nat.succ n✝) = ↑(Nat.log b (Nat.succ n✝))

tactic: simp
state_before: case succ.hr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b n✝ : ℕ
⊢ 1 ≤ ↑(Nat.succ n✝)
Theorem: SimpleGraph.Subgraph.IsMatching.toEdge.surjective
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: rintro ⟨e, he⟩
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
⊢ Function.Surjective (toEdge h)

tactic: refine Sym2.ind (fun x y he => ?_) e he
state_before: case mk
V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
e : Sym2 V
he : e ∈ edgeSet M
⊢ ∃ a, toEdge h a = { val := e, property := he }

tactic: exact ⟨⟨x, M.edge_vert he⟩, h.toEdge_eq_of_adj _ he⟩
state_before: case mk
V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
e : Sym2 V
he✝ : e ∈ edgeSet M
x y : V
he : Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet M
⊢ ∃ a, toEdge h a = { val := Quotient.mk (Sym2.Rel.setoid V) (x, y), property := he }
Theorem: eq_compl_iff_isCompl
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [h]
state_before: α : Type u
β : Type ?u.53845
w x y z : α
inst✝ : BooleanAlgebra α
h : x = yᶜ
⊢ IsCompl x y

tactic: exact isCompl_compl.symm
state_before: α : Type u
β : Type ?u.53845
w x y z : α
inst✝ : BooleanAlgebra α
h : x = yᶜ
⊢ IsCompl (yᶜ) y
Theorem: abs_sub
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [sub_eq_add_neg, ← abs_neg b]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs (a - b) ≤ abs a + abs b

tactic: exact abs_add a _
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs (a + -b) ≤ abs a + abs (-b)
Theorem: SimpleGraph.minDegree_le_degree
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: obtain ⟨t, ht⟩ := Finset.min_of_mem (mem_image_of_mem (fun v => G.degree v) (mem_univ v))
state_before: ι : Sort ?u.290851
𝕜 : Type ?u.290854
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ minDegree G ≤ degree G v

tactic: have := Finset.min_le_of_eq (mem_image_of_mem _ (mem_univ v)) ht
state_before: case intro
ι : Sort ?u.290851
𝕜 : Type ?u.290854
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : Finset.min (image (fun v => degree G v) univ) = ↑t
⊢ minDegree G ≤ degree G v

tactic: rwa [minDegree, ht]
state_before: case intro
ι : Sort ?u.290851
𝕜 : Type ?u.290854
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : Finset.min (image (fun v => degree G v) univ) = ↑t
this : t ≤ degree G v
⊢ minDegree G ≤ degree G v
Theorem: Equiv.swap_eq_update
File: Mathlib/Logic/Equiv/Basic.lean

tactic: rw [update_apply _ i j, update_apply _ j i, Equiv.swap_apply_def, id.def]
state_before: α : Sort u_1
inst✝ : DecidableEq α
i j x : α
⊢ ↑(swap i j) x = update (update id j i) i j x
Theorem: CategoryTheory.IsIso.Iso.inv_hom
File: Mathlib/CategoryTheory/Iso.lean

tactic: apply inv_eq_of_hom_inv_id
state_before: C : Type u
inst✝ : Category C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ inv f.hom = f.inv

tactic: simp
state_before: case hom_inv_id
C : Type u
inst✝ : Category C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ f.hom ≫ f.inv = 𝟙 X
Theorem: IsPiSystem.insert_univ
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: intro s hs t ht hst
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
⊢ IsPiSystem (insert univ S)

tactic: cases' hs with hs hs
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s : Set α
hs : s ∈ insert univ S
t : Set α
ht : t ∈ insert univ S
hst : Set.Nonempty (s ∩ t)
⊢ s ∩ t ∈ insert univ S

tactic: cases' ht with ht ht <;> simp [hs, ht]
state_before: case inl
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert univ S
hst : Set.Nonempty (s ∩ t)
hs : s = univ
⊢ s ∩ t ∈ insert univ S

tactic: cases' ht with ht ht
state_before: case inr
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert univ S
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
⊢ s ∩ t ∈ insert univ S

tactic: simp [hs, ht]
state_before: case inr.inl
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
ht : t = univ
⊢ s ∩ t ∈ insert univ S

tactic: exact Set.mem_insert_of_mem _ (h_pi s hs t ht hst)
state_before: case inr.inr
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
ht : t ∈ S
⊢ s ∩ t ∈ insert univ S
Theorem: LucasLehmer.X.closed_form
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: induction' i with i ih
state_before: q : ℕ+
i : ℕ
⊢ ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i

tactic: dsimp [s, ω, ωb]
state_before: case zero
q : ℕ+
⊢ ↑(s zero) = ω ^ 2 ^ zero + ωb ^ 2 ^ zero

tactic: ext <;> norm_num
state_before: case zero
q : ℕ+
⊢ ↑4 = (2, 1) ^ 1 + (2, -1) ^ 1

tactic: calc
  (s (i + 1) : X q) = (s i ^ 2 - 2 : ℤ) := rfl
  _ = (s i : X q) ^ 2 - 2 := by push_cast; rfl
  _ = (ω ^ 2 ^ i + ωb ^ 2 ^ i) ^ 2 - 2 := by rw [ih]
  _ = (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2 + 2 * (ωb ^ 2 ^ i * ω ^ 2 ^ i) - 2 := by ring
  _ = (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2 := by
    rw [← mul_pow ωb ω, ωb_mul_ω, one_pow, mul_one, add_sub_cancel]
  _ = ω ^ 2 ^ (i + 1) + ωb ^ 2 ^ (i + 1) := by rw [← pow_mul, ← pow_mul, _root_.pow_succ']
state_before: case succ
q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ ↑(s (succ i)) = ω ^ 2 ^ succ i + ωb ^ 2 ^ succ i

tactic: push_cast
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ ↑(s i ^ 2 - 2) = ↑(s i) ^ 2 - 2

tactic: rfl
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ ↑(s i) ^ 2 - 2 = ↑(s i) ^ 2 - 2

tactic: rw [ih]
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ ↑(s i) ^ 2 - 2 = (ω ^ 2 ^ i + ωb ^ 2 ^ i) ^ 2 - 2

tactic: ring
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ (ω ^ 2 ^ i + ωb ^ 2 ^ i) ^ 2 - 2 = (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2 + 2 * (ωb ^ 2 ^ i * ω ^ 2 ^ i) - 2

tactic: rw [← mul_pow ωb ω, ωb_mul_ω, one_pow, mul_one, add_sub_cancel]
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2 + 2 * (ωb ^ 2 ^ i * ω ^ 2 ^ i) - 2 = (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2

tactic: rw [← pow_mul, ← pow_mul, _root_.pow_succ']
state_before: q : ℕ+
i : ℕ
ih : ↑(s i) = ω ^ 2 ^ i + ωb ^ 2 ^ i
⊢ (ω ^ 2 ^ i) ^ 2 + (ωb ^ 2 ^ i) ^ 2 = ω ^ 2 ^ (i + 1) + ωb ^ 2 ^ (i + 1)
Theorem: Int.emod_eq_emod_iff_emod_sub_eq_zero
File: Std/Data/Int/DivMod.lean

tactic: simp [Int.sub_self]
state_before: m n k : Int
⊢ (m - k) % n = (k - k) % n ↔ (m - k) % n = 0
Theorem: Polynomial.hasseDeriv_coeff
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: rw [hasseDeriv_apply, coeff_sum, sum_def, Finset.sum_eq_single (n + k), coeff_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n : ℕ
⊢ coeff (↑(hasseDeriv k) f) n = ↑(choose (n + k) k) * coeff f (n + k)

tactic: simp only [if_true, add_tsub_cancel_right, eq_self_iff_true]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n : ℕ
⊢ (if n + k - k = n then ↑(choose (n + k) k) * coeff f (n + k) else 0) = ↑(choose (n + k) k) * coeff f (n + k)

tactic: intro i _hi hink
state_before: case h₀
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n : ℕ
⊢ ∀ (b : ℕ), b ∈ support f → b ≠ n + k → coeff (↑(monomial (b - k)) (↑(choose b k) * coeff f b)) n = 0

tactic: rw [coeff_monomial]
state_before: case h₀
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
⊢ coeff (↑(monomial (i - k)) (↑(choose i k) * coeff f i)) n = 0

tactic: by_cases hik : i < k
state_before: case h₀
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
⊢ (if i - k = n then ↑(choose i k) * coeff f i else 0) = 0

tactic: simp only [Nat.choose_eq_zero_of_lt hik, ite_self, Nat.cast_zero, MulZeroClass.zero_mul]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
hik : i < k
⊢ (if i - k = n then ↑(choose i k) * coeff f i else 0) = 0

tactic: push_neg at hik
state_before: case neg
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
hik : ¬i < k
⊢ (if i - k = n then ↑(choose i k) * coeff f i else 0) = 0

tactic: rw [if_neg]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
hik : k ≤ i
⊢ (if i - k = n then ↑(choose i k) * coeff f i else 0) = 0

tactic: contrapose! hink
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hink : i ≠ n + k
hik : k ≤ i
⊢ ¬i - k = n

tactic: exact (tsub_eq_iff_eq_add_of_le hik).mp hink
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n i : ℕ
_hi : i ∈ support f
hik : k ≤ i
hink : i - k = n
⊢ i = n + k

tactic: intro h
state_before: case h₁
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n : ℕ
⊢ ¬n + k ∈ support f → coeff (↑(monomial (n + k - k)) (↑(choose (n + k) k) * coeff f (n + k))) n = 0

tactic: simp only [not_mem_support_iff.mp h, monomial_zero_right, MulZeroClass.mul_zero, coeff_zero]
state_before: case h₁
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
n : ℕ
h : ¬n + k ∈ support f
⊢ coeff (↑(monomial (n + k - k)) (↑(choose (n + k) k) * coeff f (n + k))) n = 0
Theorem: LieSubalgebra.homOfLe_injective
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: simp only [homOfLe_apply, imp_self, Subtype.mk_eq_mk, SetLike.coe_eq_coe]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
h : K ≤ K'
x y : { x // x ∈ K }
⊢ ↑(homOfLe h) x = ↑(homOfLe h) y → x = y
Theorem: RingHom.charZero
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [← map_natCast ϕ, ← map_natCast ϕ, h]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
ϕ : R →+* S
hS : CharZero S
a b : ℕ
h : ↑a = ↑b
⊢ ↑a = ↑b
Theorem: List.append_eq_nil
File: Std/Data/List/Lemmas.lean

tactic: cases p <;> simp
state_before: α✝ : Type u_1
p q : List α✝
⊢ p ++ q = [] ↔ p = [] ∧ q = []
Theorem: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_sum_mul_norm
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: gcongr
state_before: α : Type u_1
E : Type ?u.398702
F : Type u_2
F' : Type u_3
G : Type ?u.398711
𝕜 : Type ?u.398714
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ F
⊢ ∑ x in SimpleFunc.range f, ‖T (↑f ⁻¹' {x})‖ * ‖x‖ ≤
    ∑ x in SimpleFunc.range f, C * ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖

tactic: exact hT_norm _ <| SimpleFunc.measurableSet_fiber _ _
state_before: case h.h
α : Type u_1
E : Type ?u.398702
F : Type u_2
F' : Type u_3
G : Type ?u.398711
𝕜 : Type ?u.398714
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ F
i✝ : F
a✝ : i✝ ∈ SimpleFunc.range f
⊢ ‖T (↑f ⁻¹' {i✝})‖ ≤ C * ENNReal.toReal (↑↑μ (↑f ⁻¹' {i✝}))

tactic: simp_rw [mul_sum, ← mul_assoc]
state_before: α : Type u_1
E : Type ?u.398702
F : Type u_2
F' : Type u_3
G : Type ?u.398711
𝕜 : Type ?u.398714
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ F
⊢ ∑ x in SimpleFunc.range f, C * ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖ ≤
    C * ∑ x in SimpleFunc.range f, ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖

tactic: rfl
state_before: α : Type u_1
E : Type ?u.398702
F : Type u_2
F' : Type u_3
G : Type ?u.398711
𝕜 : Type ?u.398714
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ F
⊢ ∑ x in SimpleFunc.range f, C * ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖ ≤
    ∑ x in SimpleFunc.range f, C * ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖
Theorem: IntermediateField.adjoin.range_algebraMap_subset
File: Mathlib/FieldTheory/Adjoin.lean

tactic: intro x hx
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
⊢ Set.range ↑(algebraMap F E) ⊆ ↑(adjoin F S)

tactic: cases' hx with f hf
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
hx : x ∈ Set.range ↑(algebraMap F E)
⊢ x ∈ ↑(adjoin F S)

tactic: rw [← hf]
state_before: case intro
F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : ↑(algebraMap F E) f = x
⊢ x ∈ ↑(adjoin F S)

tactic: exact adjoin.algebraMap_mem F S f
state_before: case intro
F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : ↑(algebraMap F E) f = x
⊢ ↑(algebraMap F E) f ∈ ↑(adjoin F S)
Theorem: Real.Angle.neg_pi_div_two_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_injective.ne_iff, toReal_neg_pi_div_two, toReal_zero]
state_before: ⊢ ↑(-π / 2) ≠ 0

tactic: exact div_ne_zero (neg_ne_zero.2 Real.pi_ne_zero) two_ne_zero
state_before: ⊢ -π / 2 ≠ 0
Theorem: SimpleGraph.Walk.isCycle_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u u' : V
p : Walk G u u
hu : u = u'
⊢ IsCycle (Walk.copy p hu hu) ↔ IsCycle p

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' : V
p : Walk G u' u'
⊢ IsCycle (Walk.copy p (_ : u' = u') (_ : u' = u')) ↔ IsCycle p
Theorem: Ordinal.type_fintype
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← card_eq_nat, card_type, mk_fintype]
state_before: α : Type u_1
β : Type ?u.240276
γ : Type ?u.240279
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝¹ : IsWellOrder α r
inst✝ : Fintype α
⊢ type r = ↑(Fintype.card α)
Theorem: Fin.univ_succ
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [map_eq_image]
state_before: α : Type ?u.103890
β : Type ?u.103893
γ : Type ?u.103896
n : ℕ
⊢ ¬0 ∈ map { toFun := succ, inj' := (_ : Injective succ) } univ

tactic: simp [map_eq_image]
state_before: α : Type ?u.103890
β : Type ?u.103893
γ : Type ?u.103896
n : ℕ
⊢ univ =
    cons 0 (map { toFun := succ, inj' := (_ : Injective succ) } univ)
      (_ : ¬0 ∈ map { toFun := succ, inj' := (_ : Injective succ) } univ)
Theorem: Int.zero_mod
File: Std/Data/Int/DivMod.lean

tactic: cases b <;> simp [mod]
state_before: b : Int
⊢ mod 0 b = 0
Theorem: Polynomial.monic_of_isUnit_leadingCoeff_inv_smul
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rw [Monic.def, leadingCoeff_smul_of_smul_regular _ (isSMulRegular_of_group _), Units.smul_def]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : IsUnit (leadingCoeff p)
⊢ Monic ((IsUnit.unit h)⁻¹ • p)

tactic: obtain ⟨k, hk⟩ := h
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : IsUnit (leadingCoeff p)
⊢ ↑(IsUnit.unit h)⁻¹ • leadingCoeff p = 1

tactic: simp only [← hk, smul_eq_mul, ← Units.val_mul, Units.val_eq_one, inv_mul_eq_iff_eq_mul]
state_before: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
k : Rˣ
hk : ↑k = leadingCoeff p
⊢ ↑(IsUnit.unit (_ : ∃ u, ↑u = leadingCoeff p))⁻¹ • leadingCoeff p = 1

tactic: simp [Units.ext_iff, IsUnit.unit_spec]
state_before: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
k : Rˣ
hk : ↑k = leadingCoeff p
⊢ k = IsUnit.unit (_ : IsUnit ↑k) * 1
Theorem: Nat.cast_commute
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: induction n with
| zero => rw [Nat.cast_zero]; exact Commute.zero_left x
| succ n ihn => rw [Nat.cast_succ]; exact ihn.add_left (Commute.one_left x)
state_before: α : Type u_1
β : Type ?u.6256
inst✝ : NonAssocSemiring α
n : ℕ
x : α
⊢ Commute (↑n) x

tactic: rw [Nat.cast_zero]
state_before: case zero
α : Type u_1
β : Type ?u.6256
inst✝ : NonAssocSemiring α
x : α
⊢ Commute (↑zero) x

tactic: exact Commute.zero_left x
state_before: case zero
α : Type u_1
β : Type ?u.6256
inst✝ : NonAssocSemiring α
x : α
⊢ Commute 0 x

tactic: rw [Nat.cast_succ]
state_before: case succ
α : Type u_1
β : Type ?u.6256
inst✝ : NonAssocSemiring α
x : α
n : ℕ
ihn : Commute (↑n) x
⊢ Commute (↑(succ n)) x

tactic: exact ihn.add_left (Commute.one_left x)
state_before: case succ
α : Type u_1
β : Type ?u.6256
inst✝ : NonAssocSemiring α
x : α
n : ℕ
ihn : Commute (↑n) x
⊢ Commute (↑n + 1) x
Theorem: Complex.cos_add_sin_mul_I_pow
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← exp_mul_I, ← exp_mul_I]
state_before: x y : ℂ
n : ℕ
z : ℂ
⊢ (cos z + sin z * I) ^ n = cos (↑n * z) + sin (↑n * z) * I

tactic: induction' n with n ih
state_before: x y : ℂ
n : ℕ
z : ℂ
⊢ exp (z * I) ^ n = exp (↑n * z * I)

tactic: rw [pow_zero, Nat.cast_zero, zero_mul, zero_mul, exp_zero]
state_before: case zero
x y z : ℂ
⊢ exp (z * I) ^ Nat.zero = exp (↑Nat.zero * z * I)

tactic: rw [pow_succ', ih, Nat.cast_succ, add_mul, add_mul, one_mul, exp_add]
state_before: case succ
x y z : ℂ
n : ℕ
ih : exp (z * I) ^ n = exp (↑n * z * I)
⊢ exp (z * I) ^ Nat.succ n = exp (↑(Nat.succ n) * z * I)
Theorem: ENNReal.limsup_liminf_le_liminf_limsup
File: Mathlib/Order/Filter/ENNReal.lean

tactic: rw [eventually_countable_forall]
state_before: α : Type u_2
f✝ : Filter α
β : Type u_1
inst✝¹ : Countable β
f : Filter α
inst✝ : CountableInterFilter f
g : Filter β
u : α → β → ℝ≥0∞
⊢ ∀ᶠ (a : α) in f, ∀ (b : β), u a b ≤ limsup (fun a' => u a' b) f

tactic: exact fun b => ENNReal.eventually_le_limsup fun a => u a b
state_before: α : Type u_2
f✝ : Filter α
β : Type u_1
inst✝¹ : Countable β
f : Filter α
inst✝ : CountableInterFilter f
g : Filter β
u : α → β → ℝ≥0∞
⊢ ∀ (i : β), ∀ᶠ (x : α) in f, u x i ≤ limsup (fun a' => u a' i) f
Theorem: AffineMap.decomp
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: ext x
state_before: k : Type u_1
V1 : Type u_2
P1 : Type ?u.585564
V2 : Type u_3
P2 : Type ?u.585570
V3 : Type ?u.585573
P3 : Type ?u.585576
V4 : Type ?u.585579
P4 : Type ?u.585582
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : V1 →ᵃ[k] V2
⊢ ↑f = ↑f.linear + fun x => ↑f 0

tactic: calc
  f x = f.linear x +ᵥ f 0 := by rw [← f.map_vadd, vadd_eq_add, add_zero]
  _ = (f.linear + fun _ : V1 => f 0) x := rfl
state_before: case h
k : Type u_1
V1 : Type u_2
P1 : Type ?u.585564
V2 : Type u_3
P2 : Type ?u.585570
V3 : Type ?u.585573
P3 : Type ?u.585576
V4 : Type ?u.585579
P4 : Type ?u.585582
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : V1 →ᵃ[k] V2
x : V1
⊢ ↑f x = (↑f.linear + fun x => ↑f 0) x

tactic: rw [← f.map_vadd, vadd_eq_add, add_zero]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type ?u.585564
V2 : Type u_3
P2 : Type ?u.585570
V3 : Type ?u.585573
P3 : Type ?u.585576
V4 : Type ?u.585579
P4 : Type ?u.585582
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : V1 →ᵃ[k] V2
x : V1
⊢ ↑f x = ↑f.linear x +ᵥ ↑f 0
Theorem: genLoopOneEquivPathSelf_homotopic_iff
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: rw [← genLoopOneEquivPathSelf_symm_homotopic_iff, Equiv.symm_apply_apply, Equiv.symm_apply_apply]
state_before: X : Type u
inst✝ : TopologicalSpace X
n : ℕ
x : X
f g : GenLoop 1 x
⊢ Path.Homotopic (↑genLoopOneEquivPathSelf f) (↑genLoopOneEquivPathSelf g) ↔ GenLoop.Homotopic f g