tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_mem_multiset
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: ext
state_before: ι : Type ?u.612021
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
m : Multiset α
f : { x // x ∈ m } → β
g : α → β
hfg : ∀ (x : { x // x ∈ m }), f x = g ↑x
x✝³ x✝² : { x // x ∈ m }
x✝¹ : x✝³ ∈ univ
x✝ : x✝² ∈ univ
h : (fun x x_1 => ↑x) x✝³ x✝¹ = (fun x x_1 => ↑x) x✝² x✝
⊢ x✝³ = x✝²

tactic: assumption
state_before: case a
ι : Type ?u.612021
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
m : Multiset α
f : { x // x ∈ m } → β
g : α → β
hfg : ∀ (x : { x // x ∈ m }), f x = g ↑x
x✝³ x✝² : { x // x ∈ m }
x✝¹ : x✝³ ∈ univ
x✝ : x✝² ∈ univ
h : (fun x x_1 => ↑x) x✝³ x✝¹ = (fun x x_1 => ↑x) x✝² x✝
⊢ ↑x✝³ = ↑x✝²
Theorem: Function.Injective.lieAlgebra_isNilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: obtain ⟨k, hk⟩ := id h₁
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L'
f : L →ₗ⁅R⁆ L'
h₂ : Injective ↑f
⊢ ∃ k, lowerCentralSeries R L L k = ⊥

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L'
f : L →ₗ⁅R⁆ L'
h₂ : Injective ↑f
k : ℕ
hk : lowerCentralSeries R L' L' k = ⊥
⊢ ∃ k, lowerCentralSeries R L L k = ⊥

tactic: apply LieIdeal.bot_of_map_eq_bot h₂
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L'
f : L →ₗ⁅R⁆ L'
h₂ : Injective ↑f
k : ℕ
hk : lowerCentralSeries R L' L' k = ⊥
⊢ lowerCentralSeries R L L k = ⊥

tactic: rw [eq_bot_iff, ← hk]
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L'
f : L →ₗ⁅R⁆ L'
h₂ : Injective ↑f
k : ℕ
hk : lowerCentralSeries R L' L' k = ⊥
⊢ LieIdeal.map f (lowerCentralSeries R L L k) = ⊥

tactic: apply LieIdeal.map_lowerCentralSeries_le
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L'
f : L →ₗ⁅R⁆ L'
h₂ : Injective ↑f
k : ℕ
hk : lowerCentralSeries R L' L' k = ⊥
⊢ LieIdeal.map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
Theorem: Ordnode.Raised.dist_le
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases' raised_iff.1 H with H1 H2
state_before: α : Type ?u.244025
n m : ℕ
H : Raised n m
⊢ Nat.dist n m ≤ 1

tactic: rwa [Nat.dist_eq_sub_of_le H1, tsub_le_iff_left]
state_before: case intro
α : Type ?u.244025
n m : ℕ
H : Raised n m
H1 : n ≤ m
H2 : m ≤ n + 1
⊢ Nat.dist n m ≤ 1
Theorem: inv_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [inv_le (zero_lt_one.trans_le ha) zero_lt_one, inv_one]
state_before: ι : Type ?u.52528
α : Type u_1
β : Type ?u.52534
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 1 ≤ a
⊢ a⁻¹ ≤ 1
Theorem: hasFPowerSeriesOnBall_const
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: refine' ⟨by simp, WithTop.zero_lt_top, fun _ => hasSum_single 0 fun n hn => _⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.487033
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∞
c : F
e : E
⊢ HasFPowerSeriesOnBall (fun x => c) (constFormalMultilinearSeries 𝕜 E c) e ⊤

tactic: simp [constFormalMultilinearSeries_apply hn]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.487033
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∞
c : F
e y✝ : E
x✝ : y✝ ∈ EMetric.ball 0 ⊤
n : ℕ
hn : n ≠ 0
⊢ (↑(constFormalMultilinearSeries 𝕜 E c n) fun x => y✝) = 0

tactic: simp
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.487033
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∞
c : F
e : E
⊢ ⊤ ≤ FormalMultilinearSeries.radius (constFormalMultilinearSeries 𝕜 E c)
Theorem: Complex.ofReal_inv
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r : ℝ
⊢ (↑r⁻¹).re = (↑r)⁻¹.re ∧ (↑r⁻¹).im = (↑r)⁻¹.im
Theorem: Int.eq_zero_of_ediv_eq_zero
File: Std/Data/Int/DivMod.lean

tactic: rw [← Int.mul_ediv_cancel' h, H, Int.mul_zero]
state_before: d n : Int
h : d ∣ n
H : n / d = 0
⊢ n = 0
Theorem: iteratedDerivWithin_succ
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: rw [iteratedDerivWithin_eq_iteratedFDerivWithin, iteratedFDerivWithin_succ_apply_left,
  iteratedFDerivWithin_eq_equiv_comp, LinearIsometryEquiv.comp_fderivWithin _ hxs, derivWithin]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.68719
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ iteratedDerivWithin (n + 1) f s x = derivWithin (iteratedDerivWithin n f s) s x

tactic: change ((ContinuousMultilinearMap.mkPiField 𝕜 (Fin n) ((fderivWithin 𝕜
  (iteratedDerivWithin n f s) s x : 𝕜 → F) 1) : (Fin n → 𝕜) → F) fun i : Fin n => 1) =
  (fderivWithin 𝕜 (iteratedDerivWithin n f s) s x : 𝕜 → F) 1
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.68719
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ ↑(↑(ContinuousLinearMap.comp
              (↑(ContinuousLinearEquiv.mk (ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).toLinearEquiv))
              (fderivWithin 𝕜 (iteratedDerivWithin n f s) s x))
          1)
      (Fin.tail fun x => 1) =
    ↑(fderivWithin 𝕜 (iteratedDerivWithin n f s) s x) 1

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.68719
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ (↑(ContinuousMultilinearMap.mkPiField 𝕜 (Fin n) (↑(fderivWithin 𝕜 (iteratedDerivWithin n f s) s x) 1)) fun i => 1) =
    ↑(fderivWithin 𝕜 (iteratedDerivWithin n f s) s x) 1
Theorem: IsExposed.subset
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: rintro x hx
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hAB : IsExposed 𝕜 A B
⊢ B ⊆ A

tactic: obtain ⟨_, rfl⟩ := hAB ⟨x, hx⟩
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x✝ : E
hAB : IsExposed 𝕜 A B
x : E
hx : x ∈ B
⊢ x ∈ A

tactic: exact hx.1
state_before: case intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A C : Set E
X : Finset E
x✝ x : E
w✝ : E →L[𝕜] 𝕜
hAB : IsExposed 𝕜 A {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑w✝ y ≤ ↑w✝ x}
hx : x ∈ {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑w✝ y ≤ ↑w✝ x}
⊢ x ∈ A
Theorem: Nat.le_pow_iff_clog_le
File: Mathlib/Data/Nat/Log.lean

tactic: induction' x using Nat.strong_induction_on with x ih generalizing y
state_before: b : ℕ
hb : 1 < b
x y : ℕ
⊢ x ≤ b ^ y ↔ clog b x ≤ y

tactic: cases y
state_before: case h
b : ℕ
hb : 1 < b
y✝ x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
y : ℕ
⊢ x ≤ b ^ y ↔ clog b x ≤ y

tactic: have b_pos : 0 < b := (zero_lt_one' ℕ).trans hb
state_before: case h.succ
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
n✝ : ℕ
⊢ x ≤ b ^ succ n✝ ↔ clog b x ≤ succ n✝

tactic: rw [clog]
state_before: case h.succ
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
n✝ : ℕ
b_pos : 0 < b
⊢ x ≤ b ^ succ n✝ ↔ clog b x ≤ succ n✝

tactic: split_ifs with h
state_before: case h.succ
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
n✝ : ℕ
b_pos : 0 < b
⊢ x ≤ b ^ succ n✝ ↔
    (if h : 1 < b ∧ 1 < x then
        let_fun this := (_ : (x + b - 1) / b < x);
        clog b ((x + b - 1) / b) + 1
      else 0) ≤
      succ n✝

tactic: rw [pow_zero]
state_before: case h.zero
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
⊢ x ≤ b ^ zero ↔ clog b x ≤ zero

tactic: refine' ⟨fun h => (clog_of_right_le_one h b).le, _⟩
state_before: case h.zero
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
⊢ x ≤ 1 ↔ clog b x ≤ zero

tactic: simp_rw [← not_lt]
state_before: case h.zero
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
⊢ clog b x ≤ zero → x ≤ 1

tactic: contrapose!
state_before: case h.zero
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
⊢ ¬zero < clog b x → ¬1 < x

tactic: exact clog_pos hb
state_before: case h.zero
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
⊢ 1 < x → zero < clog b x

tactic: rw [succ_eq_add_one, add_le_add_iff_right, ← ih ((x + b - 1) / b) (add_pred_div_lt hb h.2),
  Nat.div_le_iff_le_mul_add_pred b_pos, mul_comm b, ← pow_succ,
  add_tsub_assoc_of_le (Nat.succ_le_of_lt b_pos), add_le_add_iff_right]
state_before: case h.succ.inl
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
n✝ : ℕ
b_pos : 0 < b
h : 1 < b ∧ 1 < x
⊢ x ≤ b ^ succ n✝ ↔
    (let_fun this := (_ : (x + b - 1) / b < x);
      clog b ((x + b - 1) / b) + 1) ≤
      succ n✝

tactic: exact iff_of_true ((not_lt.1 (not_and.1 h hb)).trans <| succ_le_of_lt <| pow_pos b_pos _)
  (zero_le _)
state_before: case h.succ.inr
b : ℕ
hb : 1 < b
y x : ℕ
ih : ∀ (m : ℕ), m < x → ∀ {y : ℕ}, m ≤ b ^ y ↔ clog b m ≤ y
n✝ : ℕ
b_pos : 0 < b
h : ¬(1 < b ∧ 1 < x)
⊢ x ≤ b ^ succ n✝ ↔ 0 ≤ succ n✝
Theorem: Nat.prime_def_lt'
File: Mathlib/Data/Nat/Prime.lean

tactic: decide
state_before: p : ℕ
p2 : 2 ≤ p
m : ℕ
h : m < p → m ∣ p → m = 1
m2 : 2 ≤ m
l : m < p
d : m ∣ p
⊢ 1 < 2

tactic: rcases m with (_ | _ | m)
state_before: p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m → m < p → ¬m ∣ p
l : m < p
d : m ∣ p
⊢ m = 1

tactic: rw [eq_zero_of_zero_dvd d] at p2
state_before: case zero
p : ℕ
p2 : 2 ≤ p
h : 2 ≤ zero → zero < p → ¬zero ∣ p
l : zero < p
d : zero ∣ p
⊢ zero = 1

tactic: revert p2
state_before: case zero
p : ℕ
p2 : 2 ≤ 0
h : 2 ≤ zero → zero < p → ¬zero ∣ p
l : zero < p
d : zero ∣ p
⊢ zero = 1

tactic: decide
state_before: case zero
p : ℕ
h : 2 ≤ zero → zero < p → ¬zero ∣ p
l : zero < p
d : zero ∣ p
⊢ 2 ≤ 0 → zero = 1

tactic: rfl
state_before: case succ.zero
p : ℕ
p2 : 2 ≤ p
h : 2 ≤ succ zero → succ zero < p → ¬succ zero ∣ p
l : succ zero < p
d : succ zero ∣ p
⊢ succ zero = 1

tactic: exact (h le_add_self l).elim d
state_before: case succ.succ
p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ succ (succ m) → succ (succ m) < p → ¬succ (succ m) ∣ p
l : succ (succ m) < p
d : succ (succ m) ∣ p
⊢ succ (succ m) = 1
Theorem: Besicovitch.one_lt_goodτ
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: dsimp [goodτ, goodδ]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ 1 < goodτ E

tactic: linarith [(exists_goodδ E).choose_spec.1]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ 1 <
    1 +
      Exists.choose
          (_ :
            ∃ δ,
              0 < δ ∧
                δ < 1 ∧
                  ∀ (s : Finset E),
                    (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) →
                      (∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 - δ ≤ ‖c - d‖) →
                        Finset.card s ≤ multiplicity E) /
        4
Theorem: zpow_pow_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: by_cases h : IsOfFinOrder x
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
⊢ (x ^ i) ^ orderOf x = 1

tactic: rw [← zpow_ofNat, ← zpow_mul, mul_comm, zpow_mul, zpow_ofNat, pow_orderOf_eq_one, one_zpow]
state_before: case pos
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
h : IsOfFinOrder x
⊢ (x ^ i) ^ orderOf x = 1

tactic: rw [orderOf_eq_zero h, _root_.pow_zero]
state_before: case neg
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
h : ¬IsOfFinOrder x
⊢ (x ^ i) ^ orderOf x = 1
Theorem: bernstein_apply
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: dsimp [bernstein, Polynomial.toContinuousMapOn, Polynomial.toContinuousMap, bernsteinPolynomial]
state_before: n ν : ℕ
x : ↑I
⊢ ↑(bernstein n ν) x = ↑(Nat.choose n ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)

tactic: simp
state_before: n ν : ℕ
x : ↑I
⊢ Polynomial.eval (↑x) (↑(Nat.choose n ν) * Polynomial.X ^ ν * (1 - Polynomial.X) ^ (n - ν)) =
    ↑(Nat.choose n ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)
Theorem: BoxIntegral.Prepartition.le_ofWithBot
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: intro J hJ
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : Box ι), J ∈ π → ∃ J', J' ∈ boxes ∧ ↑J ≤ J'
⊢ π ≤ ofWithBot boxes le_of_mem pairwise_disjoint

tactic: rcases H J hJ with ⟨J', J'mem, hle⟩
state_before: ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : Box ι), J ∈ π → ∃ J', J' ∈ boxes ∧ ↑J ≤ J'
J : Box ι
hJ : J ∈ π
⊢ ∃ I', I' ∈ ofWithBot boxes le_of_mem pairwise_disjoint ∧ J ≤ I'

tactic: lift J' to Box ι using ne_bot_of_le_ne_bot WithBot.coe_ne_bot hle
state_before: case intro.intro
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : Box ι), J ∈ π → ∃ J', J' ∈ boxes ∧ ↑J ≤ J'
J : Box ι
hJ : J ∈ π
J' : WithBot (Box ι)
J'mem : J' ∈ boxes
hle : ↑J ≤ J'
⊢ ∃ I', I' ∈ ofWithBot boxes le_of_mem pairwise_disjoint ∧ J ≤ I'

tactic: exact ⟨J', mem_ofWithBot.2 J'mem, WithBot.coe_le_coe.1 hle⟩
state_before: case intro.intro.intro
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
boxes : Finset (WithBot (Box ι))
le_of_mem : ∀ (J : WithBot (Box ι)), J ∈ boxes → J ≤ ↑I
pairwise_disjoint : Set.Pairwise (↑boxes) Disjoint
H : ∀ (J : Box ι), J ∈ π → ∃ J', J' ∈ boxes ∧ ↑J ≤ J'
J : Box ι
hJ : J ∈ π
J' : Box ι
J'mem : ↑J' ∈ boxes
hle : ↑J ≤ ↑J'
⊢ ∃ I', I' ∈ ofWithBot boxes le_of_mem pairwise_disjoint ∧ J ≤ I'
Theorem: Cardinal.power_bit1
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [bit1, ← power_bit0, power_add, power_one]
state_before: α β : Type u
a b : Cardinal
⊢ a ^ bit1 b = a ^ b * a ^ b * a
Theorem: Set.Finite.diff
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
t : Set α
⊢ Set.Finite (s \ t)

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a✝ : Fintype ↑s
⊢ Set.Finite (s \ t)
Theorem: Ordinal.mod_eq_zero_of_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rcases H with ⟨c, rfl⟩
state_before: α : Type ?u.263181
β : Type ?u.263184
γ : Type ?u.263187
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
H : b ∣ a
⊢ a % b = 0

tactic: rcases eq_or_ne b 0 with (rfl | hb)
state_before: case intro
α : Type ?u.263181
β : Type ?u.263184
γ : Type ?u.263187
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal
⊢ b * c % b = 0

tactic: simp
state_before: case intro.inl
α : Type ?u.263181
β : Type ?u.263184
γ : Type ?u.263187
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Ordinal
⊢ 0 * c % 0 = 0

tactic: simp [mod_def, hb]
state_before: case intro.inr
α : Type ?u.263181
β : Type ?u.263184
γ : Type ?u.263187
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal
hb : b ≠ 0
⊢ b * c % b = 0
Theorem: Nat.factorization_zero
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization]
state_before: ⊢ factorization 0 = 0
Theorem: exists_seq_strictMono_tendsto
File: Mathlib/Topology/Order/Basic.lean

tactic: obtain ⟨y, hy⟩ : ∃ y, y < x := exists_lt x
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁸ : TopologicalSpace α
inst✝⁷ : TopologicalSpace β
inst✝⁶ : LinearOrder α
inst✝⁵ : LinearOrder β
inst✝⁴ : OrderTopology α
inst✝³ : OrderTopology β
inst✝² : DenselyOrdered α
inst✝¹ : NoMinOrder α
inst✝ : FirstCountableTopology α
x : α
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Tendsto u atTop (𝓝 x)

tactic: rcases exists_seq_strictMono_tendsto' hy with ⟨u, hu_mono, hu_mem, hux⟩
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝⁸ : TopologicalSpace α
inst✝⁷ : TopologicalSpace β
inst✝⁶ : LinearOrder α
inst✝⁵ : LinearOrder β
inst✝⁴ : OrderTopology α
inst✝³ : OrderTopology β
inst✝² : DenselyOrdered α
inst✝¹ : NoMinOrder α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Tendsto u atTop (𝓝 x)

tactic: exact ⟨u, hu_mono, fun n => (hu_mem n).2, hux⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝⁸ : TopologicalSpace α
inst✝⁷ : TopologicalSpace β
inst✝⁶ : LinearOrder α
inst✝⁵ : LinearOrder β
inst✝⁴ : OrderTopology α
inst✝³ : OrderTopology β
inst✝² : DenselyOrdered α
inst✝¹ : NoMinOrder α
inst✝ : FirstCountableTopology α
x y : α
hy : y < x
u : ℕ → α
hu_mono : StrictMono u
hu_mem : ∀ (n : ℕ), u n ∈ Ioo y x
hux : Tendsto u atTop (𝓝 x)
⊢ ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Tendsto u atTop (𝓝 x)
Theorem: monomial_has_deriv_aux
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: simp_rw [sub_eq_neg_add]
state_before: 𝕜 : Type ?u.246282
E : Type ?u.246285
F : Type ?u.246288
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (x - y) ^ (n + 1)) (-(↑n + 1) * (x - t) ^ n) t

tactic: rw [← neg_one_mul, mul_comm (-1 : ℝ), mul_assoc, mul_comm (-1 : ℝ), ← mul_assoc]
state_before: 𝕜 : Type ?u.246282
E : Type ?u.246285
F : Type ?u.246288
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) (-(↑n + 1) * (-t + x) ^ n) t

tactic: convert HasDerivAt.pow (n + 1) ((hasDerivAt_id t).neg.add_const x)
state_before: 𝕜 : Type ?u.246282
E : Type ?u.246285
F : Type ?u.246288
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) ((↑n + 1) * (-t + x) ^ n * -1) t

tactic: simp only [Nat.cast_add, Nat.cast_one]
state_before: case h.e'_7.h.e'_5.h.e'_5
𝕜 : Type ?u.246282
E : Type ?u.246285
F : Type ?u.246288
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ ↑n + 1 = ↑(n + 1)
Theorem: Polynomial.eval₂_eq_sum_range'
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval₂_eq_sum, p.sum_over_range' _ _ hn]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f✝ : R →+* S
x✝ : S
f : R →+* S
p : R[X]
n : ℕ
hn : natDegree p < n
x : S
⊢ eval₂ f x p = ∑ i in range n, ↑f (coeff p i) * x ^ i

tactic: intro i
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f✝ : R →+* S
x✝ : S
f : R →+* S
p : R[X]
n : ℕ
hn : natDegree p < n
x : S
⊢ ∀ (n : ℕ), ↑f 0 * x ^ n = 0

tactic: rw [f.map_zero, zero_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f✝ : R →+* S
x✝ : S
f : R →+* S
p : R[X]
n : ℕ
hn : natDegree p < n
x : S
i : ℕ
⊢ ↑f 0 * x ^ i = 0
Theorem: MvPolynomial.X_pow_eq_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp [X, monomial_pow]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ X n ^ e = ↑(monomial (Finsupp.single n e)) 1
Theorem: Bornology.inCompact.isBounded_iff
File: Mathlib/Topology/SubsetProperties.lean

tactic: change sᶜ ∈ Filter.cocompact α ↔ _
state_before: α : Type u
β : Type v
ι : Type ?u.53826
π : ι → Type ?u.53831
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ IsBounded s ↔ ∃ t, IsCompact t ∧ s ⊆ t

tactic: rw [Filter.mem_cocompact]
state_before: α : Type u
β : Type v
ι : Type ?u.53826
π : ι → Type ?u.53831
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ sᶜ ∈ cocompact α ↔ ∃ t, IsCompact t ∧ s ⊆ t

tactic: simp
state_before: α : Type u
β : Type v
ι : Type ?u.53826
π : ι → Type ?u.53831
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ (∃ t, IsCompact t ∧ tᶜ ⊆ sᶜ) ↔ ∃ t, IsCompact t ∧ s ⊆ t
Theorem: Composition.boundary_last
File: Mathlib/Combinatorics/Composition.lean

tactic: simp [boundary, Fin.ext_iff]
state_before: n : ℕ
c : Composition n
⊢ ↑(boundary c) (Fin.last (length c)) = Fin.last n