tasksource/leandojo huggingface dataset:
Theorem: List.getD_eq_get
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH generalizing n
state_before: ι : Type ?u.501723
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
hn : n < length l
⊢ getD l n d = get l { val := n, isLt := hn }

tactic: exact absurd hn (not_lt_of_ge (Nat.zero_le _))
state_before: case nil
ι : Type ?u.501723
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ : ℕ
hn✝ : n✝ < length l
n : ℕ
hn : n < length []
⊢ getD [] n d = get [] { val := n, isLt := hn }

tactic: cases n
state_before: case cons
ι : Type ?u.501723
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ : ℕ
hn✝ : n✝ < length l
hd : α
tl : List α
IH : ∀ {n : ℕ} (hn : n < length tl), getD tl n d = get tl { val := n, isLt := hn }
n : ℕ
hn : n < length (hd :: tl)
⊢ getD (hd :: tl) n d = get (hd :: tl) { val := n, isLt := hn }

tactic: exact getD_cons_zero _ _ _
state_before: case cons.zero
ι : Type ?u.501723
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
hn✝ : n < length l
hd : α
tl : List α
IH : ∀ {n : ℕ} (hn : n < length tl), getD tl n d = get tl { val := n, isLt := hn }
hn : zero < length (hd :: tl)
⊢ getD (hd :: tl) zero d = get (hd :: tl) { val := zero, isLt := hn }

tactic: exact IH _
state_before: case cons.succ
ι : Type ?u.501723
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n : ℕ
hn✝ : n < length l
hd : α
tl : List α
IH : ∀ {n : ℕ} (hn : n < length tl), getD tl n d = get tl { val := n, isLt := hn }
n✝ : ℕ
hn : succ n✝ < length (hd :: tl)
⊢ getD (hd :: tl) (succ n✝) d = get (hd :: tl) { val := succ n✝, isLt := hn }
Theorem: Int.neg_div_neg
File: Std/Data/Int/DivMod.lean

tactic: simp [Int.div_neg, Int.neg_div, Int.neg_neg]
state_before: a b : Int
⊢ div (-a) (-b) = div a b
Theorem: List.map_filterMap_of_inv
File: Std/Data/List/Lemmas.lean

tactic: simp only [map_filterMap, H, filterMap_some]
state_before: α : Type u_1
β : Type u_2
f : α → Option β
g : β → α
H : ∀ (x : α), Option.map g (f x) = some x
l : List α
⊢ map g (filterMap f l) = l
Theorem: not_covby_iff
File: Mathlib/Order/Cover.lean

tactic: simp_rw [Covby, h, true_and_iff, not_forall, exists_prop, not_not]
state_before: α : Type u_1
β : Type ?u.26802
inst✝ : LT α
a b : α
h : a < b
⊢ ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b
Theorem: exists_lt_of_lt_csSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: contrapose! hb
state_before: α : Type u_1
β : Type ?u.67098
γ : Type ?u.67101
ι : Sort ?u.67104
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
hs : Set.Nonempty s
hb : b < sSup s
⊢ ∃ a, a ∈ s ∧ b < a

tactic: exact csSup_le hs hb
state_before: α : Type u_1
β : Type ?u.67098
γ : Type ?u.67101
ι : Sort ?u.67104
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
hs : Set.Nonempty s
hb : ∀ (a : α), a ∈ s → a ≤ b
⊢ sSup s ≤ b
Theorem: MvPolynomial.X_mem_supported
File: Mathlib/Data/MvPolynomial/Supported.lean

tactic: simp [mem_supported]
state_before: σ : Type u_1
τ : Type ?u.128582
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
i : σ
⊢ X i ∈ supported R s ↔ i ∈ s
Theorem: Seminorm.neg_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type ?u.1261867
R' : Type ?u.1261870
𝕜 : Type u_1
𝕜₂ : Type ?u.1261876
𝕜₃ : Type ?u.1261879
𝕝 : Type ?u.1261882
E : Type u_2
E₂ : Type ?u.1261888
E₃ : Type ?u.1261891
F : Type ?u.1261894
G : Type ?u.1261897
ι : Type ?u.1261900
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x✝ : E
p : Seminorm 𝕜 E
r : ℝ
x : E
⊢ -ball p x r = ball p (-x) r

tactic: rw [mem_neg, mem_ball, mem_ball, ← neg_add', sub_neg_eq_add, map_neg_eq_map]
state_before: case h
R : Type ?u.1261867
R' : Type ?u.1261870
𝕜 : Type u_1
𝕜₂ : Type ?u.1261876
𝕜₃ : Type ?u.1261879
𝕝 : Type ?u.1261882
E : Type u_2
E₂ : Type ?u.1261888
E₃ : Type ?u.1261891
F : Type ?u.1261894
G : Type ?u.1261897
ι : Type ?u.1261900
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x✝¹ : E
p : Seminorm 𝕜 E
r : ℝ
x x✝ : E
⊢ x✝ ∈ -ball p x r ↔ x✝ ∈ ball p (-x) r
Theorem: RatFunc.denom_add_dvd
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [denom_dvd (mul_ne_zero (denom_ne_zero x) (denom_ne_zero y))]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ denom (x + y) ∣ denom x * denom y

tactic: refine' ⟨x.num * y.denom + x.denom * y.num, _⟩
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x + y = ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)

tactic: rw [RingHom.map_mul, RingHom.map_add, RingHom.map_mul, RingHom.map_mul, ← div_add_div,
  num_div_denom, num_div_denom]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x + y =
    ↑(algebraMap K[X] (RatFunc K)) (num x * denom y + denom x * num y) /
      ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)

tactic: exact algebraMap_ne_zero (denom_ne_zero x)
state_before: case hb
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (denom x) ≠ 0

tactic: exact algebraMap_ne_zero (denom_ne_zero y)
state_before: case hd
K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ↑(algebraMap K[X] (RatFunc K)) (denom y) ≠ 0
Theorem: edist_le_Ico_sum_edist
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: induction n, h using Nat.le_induction
state_before: α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n : ℕ
h : m ≤ n
⊢ edist (f m) (f n) ≤ ∑ i in Finset.Ico m n, edist (f i) (f (i + 1))

tactic: case base => rw [Finset.Ico_self, Finset.sum_empty, edist_self]
state_before: case base
α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n : ℕ
⊢ edist (f m) (f m) ≤ ∑ i in Finset.Ico m m, edist (f i) (f (i + 1))

case succ
α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n n✝ : ℕ
hn✝ : m ≤ n✝
a✝ : edist (f m) (f n✝) ≤ ∑ i in Finset.Ico m n✝, edist (f i) (f (i + 1))
⊢ edist (f m) (f (n✝ + 1)) ≤ ∑ i in Finset.Ico m (n✝ + 1), edist (f i) (f (i + 1))

tactic: case succ n hle ihn =>
  calc
    edist (f m) (f (n + 1)) ≤ edist (f m) (f n) + edist (f n) (f (n + 1)) := edist_triangle _ _ _
    _ ≤ (∑ i in Finset.Ico m n, _) + _ := add_le_add ihn le_rfl
    _ = ∑ i in Finset.Ico m (n + 1), _ := by
    { rw [Nat.Ico_succ_right_eq_insert_Ico hle, Finset.sum_insert, add_comm]; simp }
state_before: case succ
α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n n✝ : ℕ
hn✝ : m ≤ n✝
a✝ : edist (f m) (f n✝) ≤ ∑ i in Finset.Ico m n✝, edist (f i) (f (i + 1))
⊢ edist (f m) (f (n✝ + 1)) ≤ ∑ i in Finset.Ico m (n✝ + 1), edist (f i) (f (i + 1))

tactic: rw [Finset.Ico_self, Finset.sum_empty, edist_self]
state_before: α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n : ℕ
⊢ edist (f m) (f m) ≤ ∑ i in Finset.Ico m m, edist (f i) (f (i + 1))

tactic: calc
  edist (f m) (f (n + 1)) ≤ edist (f m) (f n) + edist (f n) (f (n + 1)) := edist_triangle _ _ _
  _ ≤ (∑ i in Finset.Ico m n, _) + _ := add_le_add ihn le_rfl
  _ = ∑ i in Finset.Ico m (n + 1), _ := by
  { rw [Nat.Ico_succ_right_eq_insert_Ico hle, Finset.sum_insert, add_comm]; simp }
state_before: α : Type u
β : Type v
X : Type ?u.8135
inst✝ : PseudoEMetricSpace α
f : ℕ → α
m n✝ n : ℕ
hle : m ≤ n
ihn : edist (f m) (f n) ≤ ∑ i in Finset.Ico m n, edist (f i) (f (i + 1))
⊢ edist (f m) (f (n + 1)) ≤ ∑ i in Finset.Ico m (n + 1), edist (f i) (f (i + 1))
Theorem: HasStrictDerivAt.sum
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa [ContinuousLinearMap.sum_apply] using (HasStrictFDerivAt.sum h).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
ι : Type u_1
u : Finset ι
A : ι → 𝕜 → F
A' : ι → F
h : ∀ (i : ι), i ∈ u → HasStrictDerivAt (A i) (A' i) x
⊢ HasStrictDerivAt (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x
Theorem: mem_comp_of_mem_ball
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [mem_ball_symmetry hV] at hx
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.55323
inst✝ : UniformSpace α
V W : Set (β × β)
x y z : β
hV : SymmetricRel V
hx : x ∈ ball z V
hy : y ∈ ball z W
⊢ (x, y) ∈ V ○ W

tactic: exact ⟨z, hx, hy⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.55323
inst✝ : UniformSpace α
V W : Set (β × β)
x y z : β
hV : SymmetricRel V
hx : z ∈ ball x V
hy : y ∈ ball z W
⊢ (x, y) ∈ V ○ W
Theorem: PFunctor.Approx.truncate_eq_of_agree
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: induction n <;> cases x <;> cases y
state_before: F : PFunctor
n : ℕ
x : CofixA F n
y : CofixA F (succ n)
h : Agree x y
⊢ truncate y = x

tactic: rfl
state_before: case zero.continue.intro
F : PFunctor
a✝¹ : F.A
a✝ : B F a✝¹ → CofixA F 0
h : Agree CofixA.continue (CofixA.intro a✝¹ a✝)
⊢ truncate (CofixA.intro a✝¹ a✝) = CofixA.continue

tactic: cases h
state_before: case succ.intro.intro
F : PFunctor
n✝ : ℕ
n_ih✝ : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a✝³ : F.A
a✝² : B F a✝³ → CofixA F n✝
a✝¹ : F.A
a✝ : B F a✝¹ → CofixA F (succ n✝)
h : Agree (CofixA.intro a✝³ a✝²) (CofixA.intro a✝¹ a✝)
⊢ truncate (CofixA.intro a✝¹ a✝) = CofixA.intro a✝³ a✝²

tactic: simp only [truncate, Function.comp, true_and_iff, eq_self_iff_true, heq_iff_eq]
state_before: case succ.intro.intro.intro
F : PFunctor
n✝ : ℕ
n_ih✝ : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a✝² : F.A
a✝¹ : B F a✝² → CofixA F n✝
x'✝ : B F a✝² → CofixA F (n✝ + 1)
a✝ : ∀ (i : B F a✝²), Agree (a✝¹ i) (x'✝ i)
⊢ truncate (CofixA.intro a✝² x'✝) = CofixA.intro a✝² a✝¹

tactic: rename_i n_ih a f y h₁
state_before: case succ.intro.intro.intro
F : PFunctor
n✝ : ℕ
n_ih✝ : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a✝² : F.A
a✝¹ : B F a✝² → CofixA F n✝
x'✝ : B F a✝² → CofixA F (n✝ + 1)
a✝ : ∀ (i : B F a✝²), Agree (a✝¹ i) (x'✝ i)
⊢ (CofixA.intro a✝² fun x => truncate (x'✝ x)) = CofixA.intro a✝² a✝¹

tactic: suffices (fun x => truncate (y x)) = f
  by simp [this]; try (exact HEq.rfl;)
state_before: case succ.intro.intro.intro
F : PFunctor
n✝ : ℕ
n_ih : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a : F.A
f : B F a → CofixA F n✝
y : B F a → CofixA F (n✝ + 1)
h₁ : ∀ (i : B F a), Agree (f i) (y i)
⊢ (CofixA.intro a fun x => truncate (y x)) = CofixA.intro a f

tactic: funext y
state_before: case succ.intro.intro.intro
F : PFunctor
n✝ : ℕ
n_ih : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a : F.A
f : B F a → CofixA F n✝
y : B F a → CofixA F (n✝ + 1)
h₁ : ∀ (i : B F a), Agree (f i) (y i)
⊢ (fun x => truncate (y x)) = f

tactic: apply n_ih
state_before: case succ.intro.intro.intro.h
F : PFunctor
n✝ : ℕ
n_ih : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a : F.A
f : B F a → CofixA F n✝
y✝ : B F a → CofixA F (n✝ + 1)
h₁ : ∀ (i : B F a), Agree (f i) (y✝ i)
y : B F a
⊢ truncate (y✝ y) = f y

tactic: apply h₁
state_before: case succ.intro.intro.intro.h.h
F : PFunctor
n✝ : ℕ
n_ih : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a : F.A
f : B F a → CofixA F n✝
y✝ : B F a → CofixA F (n✝ + 1)
h₁ : ∀ (i : B F a), Agree (f i) (y✝ i)
y : B F a
⊢ Agree (f y) (y✝ y)

tactic: simp [this]
state_before: F : PFunctor
n✝ : ℕ
n_ih : ∀ (x : CofixA F n✝) (y : CofixA F (succ n✝)), Agree x y → truncate y = x
a : F.A
f : B F a → CofixA F n✝
y : B F a → CofixA F (n✝ + 1)
h₁ : ∀ (i : B F a), Agree (f i) (y i)
this : (fun x => truncate (y x)) = f
⊢ (CofixA.intro a fun x => truncate (y x)) = CofixA.intro a f
Theorem: GroupFilterBasis.mem_nhds_one
File: Mathlib/Topology/Algebra/FilterBasis.lean

tactic: rw [B.nhds_one_hasBasis.mem_iff]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
U : Set G
hU : U ∈ B
⊢ U ∈ 𝓝 1

tactic: exact ⟨U, hU, rfl.subset⟩
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
U : Set G
hU : U ∈ B
⊢ ∃ i, i ∈ B ∧ id i ⊆ U
Theorem: Fin.coe_sub
File: Mathlib/Data/Fin/Basic.lean

tactic: cases a
state_before: n m : ℕ
a b : Fin n
⊢ ↑(a - b) = (↑a + (n - ↑b)) % n

tactic: cases b
state_before: case mk
n m : ℕ
b : Fin n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ ↑({ val := val✝, isLt := isLt✝ } - b) = (↑{ val := val✝, isLt := isLt✝ } + (n - ↑b)) % n

tactic: rfl
state_before: case mk.mk
n m val✝¹ : ℕ
isLt✝¹ : val✝¹ < n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ ↑({ val := val✝¹, isLt := isLt✝¹ } - { val := val✝, isLt := isLt✝ }) =
    (↑{ val := val✝¹, isLt := isLt✝¹ } + (n - ↑{ val := val✝, isLt := isLt✝ })) % n
Theorem: Function.iterate_comm
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [Nat.mul_comm]
state_before: α : Type u
β : Type v
f✝ : α → α
m✝ n✝ : ℕ
a : α
f : α → α
m n : ℕ
⊢ f^[n * m] = f^[m * n]
Theorem: Nat.sub_add_cancel
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_comm, Nat.add_sub_of_le h]
state_before: n m : Nat
h : m ≤ n
⊢ n - m + m = n
Theorem: Polynomial.coeff_C_mul_X_pow
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [C_mul_X_pow_eq_monomial, coeff_monomial]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
k n : ℕ
⊢ coeff (↑C x * X ^ k) n = if n = k then x else 0

tactic: congr 1
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
k n : ℕ
⊢ (if k = n then x else 0) = if n = k then x else 0

tactic: simp [eq_comm]
state_before: case e_c
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
k n : ℕ
⊢ (k = n) = (n = k)
Theorem: support_deriv_subset
File: Mathlib/Analysis/Calculus/Deriv/Support.lean

tactic: intro x
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
⊢ support (deriv f) ⊆ tsupport f

tactic: rw [← not_imp_not]
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
x : 𝕜
⊢ x ∈ support (deriv f) → x ∈ tsupport f

tactic: intro h2x
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
x : 𝕜
⊢ ¬x ∈ tsupport f → ¬x ∈ support (deriv f)

tactic: rw [not_mem_tsupport_iff_eventuallyEq] at h2x
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
x : 𝕜
h2x : ¬x ∈ tsupport f
⊢ ¬x ∈ support (deriv f)

tactic: exact nmem_support.mpr (h2x.deriv_eq.trans (deriv_const x 0))
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
x : 𝕜
h2x : f =ᶠ[nhds x] 0
⊢ ¬x ∈ support (deriv f)
Theorem: QuaternionGroup.xa_sq
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: simp [sq]
state_before: n : ℕ
i : ZMod (2 * n)
⊢ xa i ^ 2 = a ↑n
Theorem: smul_zpow
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: cases p <;>
simp [smul_pow, smul_inv]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : Group α
inst✝³ : MulAction α β
inst✝² : Group β
inst✝¹ : SMulCommClass α β β
inst✝ : IsScalarTower α β β
c : α
x : β
p : ℤ
⊢ (c • x) ^ p = c ^ p • x ^ p
Theorem: LieAlgebra.derivedSeries_of_bot_eq_bot
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [eq_bot_iff]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ D k ⊥ = ⊥

tactic: exact derivedSeriesOfIdeal_le_self ⊥ k
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ D k ⊥ ≤ ⊥
Theorem: AddMonoidAlgebra.modOf_add_divOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: rw [add_comm, divOf_add_modOf]
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g : G
⊢ x %ᵒᶠ g + of' k G g * (x /ᵒᶠ g) = x
Theorem: MeasureTheory.AEEqFun.coeFn_compMeasurable
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [compMeasurable_eq_mk]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.390095
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ ↑(compMeasurable g hg f) =ᵐ[μ] g ∘ ↑f

tactic: apply coeFn_mk
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.390095
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ ↑(mk (g ∘ ↑f) (_ : AEStronglyMeasurable (g ∘ ↑f) μ)) =ᵐ[μ] g ∘ ↑f
Theorem: Set.neg_smul_set
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← image_smul, ← image_neg, image_image, neg_smul]
state_before: F : Type ?u.218829
α : Type u_2
β : Type u_1
γ : Type ?u.218838
inst✝² : Ring α
inst✝¹ : AddCommGroup β
inst✝ : Module α β
a : α
s : Set α
t : Set β
⊢ -a • t = -(a • t)
Theorem: ApplicativeTransformation.preserves_map
File: Mathlib/Control/Traversable/Basic.lean

tactic: rw [← pure_seq, η.preserves_seq, preserves_pure, pure_seq]
state_before: F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
y : F α
⊢ (fun {α} => app η α) (x <$> y) = x <$> (fun {α} => app η α) y
Theorem: Cardinal.mul_le_max_of_aleph0_le_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simpa only [mul_comm b, max_comm b] using mul_le_max_of_aleph0_le_left h
state_before: a b : Cardinal
h : ℵ₀ ≤ b
⊢ a * b ≤ max a b
Theorem: Real.tan_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [← Complex.ofReal_ne_zero, Complex.ofReal_tan, Complex.tan_ne_zero_iff]
state_before: θ : ℝ
⊢ tan θ ≠ 0 ↔ ∀ (k : ℤ), θ ≠ ↑k * π / 2

tactic: norm_cast
state_before: θ : ℝ
⊢ (∀ (k : ℤ), ↑θ ≠ ↑k * ↑π / 2) ↔ ∀ (k : ℤ), θ ≠ ↑k * π / 2
Theorem: Equiv.Perm.isConj_iff_cycleType_eq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: obtain ⟨π, rfl⟩ := isConj_iff.1 h
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : IsConj σ τ
⊢ cycleType σ = cycleType τ

tactic: rw [cycleType_conj]
state_before: case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ π : Perm α
h : IsConj σ (π * σ * π⁻¹)
⊢ cycleType σ = cycleType (π * σ * π⁻¹)
Theorem: Complex.I_mul_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: ⊢ (I * I).re = (-1).re ∧ (I * I).im = (-1).im
Theorem: CategoryTheory.eq_of_comp_right_eq'
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert congr_fun (congr_fun w X) h
state_before: C : Type u
inst✝ : Category C
X✝ Y Z : C
f g : Y ⟶ Z
w : (fun {X} h => h ≫ f) = fun {X} h => h ≫ g
X : C
h : X ⟶ Y
⊢ h ≫ f = h ≫ g
Theorem: Matrix.cons_transpose
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
v : n' → α
A : Matrix (Fin m) n' α
⊢ (↑of (vecCons v A))ᵀ = ↑of fun i => vecCons (v i) (Aᵀ i)

tactic: refine' Fin.cases _ _ j <;> simp
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
v : n' → α
A : Matrix (Fin m) n' α
i : n'
j : Fin (Nat.succ m)
⊢ (↑of (vecCons v A))ᵀ i j = ↑of (fun i => vecCons (v i) (Aᵀ i)) i j
Theorem: Polynomial.derivative_nat_cast
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [← map_natCast C n]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
n : ℕ
⊢ ↑derivative ↑n = 0

tactic: exact derivative_C
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
n : ℕ
⊢ ↑derivative (↑C ↑n) = 0
Theorem: MeasureTheory.SignedMeasure.of_inter_eq_of_symmDiff_eq_zero_negative
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [← s.neg_le_neg_iff _ hu, neg_zero] at hsu
state_before: α : Type u_1
β : Type ?u.67068
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict s u ≤ VectorMeasure.restrict 0 u
hsv : VectorMeasure.restrict s v ≤ VectorMeasure.restrict 0 v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (w ∩ u) = ↑s (w ∩ v)

tactic: rw [← s.neg_le_neg_iff _ hv, neg_zero] at hsv
state_before: α : Type u_1
β : Type ?u.67068
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict s v ≤ VectorMeasure.restrict 0 v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (w ∩ u) = ↑s (w ∩ v)

tactic: have := of_inter_eq_of_symmDiff_eq_zero_positive hu hv hw hsu hsv
state_before: α : Type u_1
β : Type ?u.67068
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (w ∩ u) = ↑s (w ∩ v)

tactic: simp only [Pi.neg_apply, neg_inj, neg_eq_zero, coe_neg] at this
state_before: α : Type u_1
β : Type ?u.67068
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
this : ↑(-s) (u ∆ v) = 0 → ↑(-s) (w ∩ u) = ↑(-s) (w ∩ v)
⊢ ↑s (w ∩ u) = ↑s (w ∩ v)

tactic: exact this hs
state_before: α : Type u_1
β : Type ?u.67068
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
this : ↑s (u ∆ v) = 0 → ↑s (w ∩ u) = ↑s (w ∩ v)
⊢ ↑s (w ∩ u) = ↑s (w ∩ v)
Theorem: Complex.exp_im
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp_eq_exp_re_mul_sin_add_cos]
state_before: x y : ℂ
⊢ (exp x).im = Real.exp x.re * Real.sin x.im

tactic: simp [exp_ofReal_re, sin_ofReal_re]
state_before: x y : ℂ
⊢ (exp ↑x.re * (cos ↑x.im + sin ↑x.im * I)).im = Real.exp x.re * Real.sin x.im
Theorem: Submodule.fg_iSup
File: Mathlib/RingTheory/Finiteness.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u_2
M : Type u_3
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
ι : Type u_1
inst✝ : Finite ι
N : ι → Submodule R M
h : ∀ (i : ι), FG (N i)
⊢ FG (iSup N)

tactic: simpa using fg_biSup Finset.univ N fun i _ => h i
state_before: case intro
R : Type u_2
M : Type u_3
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
ι : Type u_1
inst✝ : Finite ι
N : ι → Submodule R M
h : ∀ (i : ι), FG (N i)
val✝ : Fintype ι
⊢ FG (iSup N)