tasksource/leandojo huggingface dataset:
Theorem: Finset.normalize_lcm
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: simp [lcm_def]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5029
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
⊢ ↑normalize (lcm s f) = lcm s f
Theorem: Set.projIcc_of_le_left
File: Mathlib/Data/Set/Intervals/ProjIcc.lean

tactic: simp [projIcc, hx, hx.trans h]
state_before: α : Type u_1
β : Type ?u.573
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x : α
hx : x ≤ a
⊢ projIcc a b h x = { val := a, property := (_ : a ∈ Icc a b) }
Theorem: Finset.powersetLen_zero
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext
state_before: α : Type u_1
s✝ t s : Finset α
⊢ powersetLen 0 s = {∅}

tactic: rw [mem_powersetLen, mem_singleton, card_eq_zero]
state_before: case a
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetLen 0 s ↔ a✝ ∈ {∅}

tactic: refine'
  ⟨fun h => h.2, fun h => by
    rw [h]
    exact ⟨empty_subset s, rfl⟩⟩
state_before: case a
α : Type u_1
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝ = ∅ ↔ a✝ = ∅

tactic: rw [h]
state_before: α : Type u_1
s✝ t s a✝ : Finset α
h : a✝ = ∅
⊢ a✝ ⊆ s ∧ a✝ = ∅

tactic: exact ⟨empty_subset s, rfl⟩
state_before: α : Type u_1
s✝ t s a✝ : Finset α
h : a✝ = ∅
⊢ ∅ ⊆ s ∧ ∅ = ∅
Theorem: MvPowerSeries.coeff_monomial
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff, monomial_def, LinearMap.proj_apply]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
m n : σ →₀ ℕ
a : R
⊢ ↑(coeff R m) (↑(monomial R n) a) = if m = n then a else 0

tactic: dsimp only
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
m n : σ →₀ ℕ
a : R
⊢ ↑(LinearMap.stdBasis R (fun x => R) n) a m = if m = n then a else 0

tactic: rw [LinearMap.stdBasis_apply, Function.update_apply, Pi.zero_apply]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
m n : σ →₀ ℕ
a : R
⊢ ↑(LinearMap.stdBasis R (fun x => R) n) a m = if m = n then a else 0
Theorem: Matrix.scalar_apply_eq
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [coe_scalar, Matrix.smul_apply, one_apply_eq, smul_eq_mul, mul_one]
state_before: l : Type ?u.432380
m : Type ?u.432383
n : Type u_1
o : Type ?u.432389
m' : o → Type ?u.432394
n' : o → Type ?u.432399
R : Type ?u.432402
S : Type ?u.432405
α : Type v
β : Type w
γ : Type ?u.432412
inst✝² : Semiring α
inst✝¹ : DecidableEq n
inst✝ : Fintype n
a : α
i : n
⊢ ↑(scalar n) a i i = a
Theorem: PGame.lf_iff_exists_le
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [Lf, le_iff_forall_lf, not_and_or]
state_before: x y : PGame
⊢ x ⧏ y ↔ (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y

tactic: simp
state_before: x y : PGame
⊢ ((¬∀ (i : LeftMoves y), moveLeft y i ⧏ x) ∨ ¬∀ (j : RightMoves x), y ⧏ moveRight x j) ↔
    (∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y
Theorem: Polynomial.support_smul
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: intro i hi
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝² : Semiring R
p✝ q r✝ : R[X]
inst✝¹ : Monoid S
inst✝ : DistribMulAction S R
r : S
p : R[X]
⊢ support (r • p) ⊆ support p

tactic: simp [mem_support_iff] at hi⊢
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝² : Semiring R
p✝ q r✝ : R[X]
inst✝¹ : Monoid S
inst✝ : DistribMulAction S R
r : S
p : R[X]
i : ℕ
hi : i ∈ support (r • p)
⊢ i ∈ support p

tactic: contrapose! hi
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝² : Semiring R
p✝ q r✝ : R[X]
inst✝¹ : Monoid S
inst✝ : DistribMulAction S R
r : S
p : R[X]
i : ℕ
hi : ¬r • coeff p i = 0
⊢ ¬coeff p i = 0

tactic: simp [hi]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝² : Semiring R
p✝ q r✝ : R[X]
inst✝¹ : Monoid S
inst✝ : DistribMulAction S R
r : S
p : R[X]
i : ℕ
hi : coeff p i = 0
⊢ r • coeff p i = 0
Theorem: LatticeOrderedCommGroup.sup_div_inf_eq_abs_div
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [sup_eq_mul_pos_div, inf_comm, inf_eq_div_pos_div, div_eq_mul_inv, div_eq_mul_inv b ((b / a)⁺),
  mul_inv_rev, inv_inv, mul_comm, ← mul_assoc, inv_mul_cancel_right, pos_eq_neg_inv (a / b),
  div_eq_mul_inv a b, mul_inv_rev, ← div_eq_mul_inv, inv_inv, ← pos_mul_neg]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊔ b) / (a ⊓ b) = abs (b / a)
Theorem: mul_div_mul_left_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_inv_rev, mul_comm b⁻¹ c⁻¹, mul_comm c a, mul_assoc, ←mul_assoc c,
  mul_right_inv, one_mul, div_eq_mul_inv]
state_before: α : Type ?u.65645
β : Type ?u.65648
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ c * a / (c * b) = a / b
Theorem: Zsqrtd.coprime_of_dvd_coprime
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: apply isCoprime_of_dvd
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
⊢ IsCoprime b.re b.im

tactic: rintro ⟨hre, him⟩
state_before: case nonzero
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
⊢ ¬(b.re = 0 ∧ b.im = 0)

tactic: obtain rfl : b = 0 := by
  simp only [ext, hre, eq_self_iff_true, zero_im, him, and_self_iff, zero_re]
state_before: case nonzero.intro
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
hre : b.re = 0
him : b.im = 0
⊢ False

tactic: rw [zero_dvd_iff] at hdvd
state_before: case nonzero.intro
d : ℤ
a : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : 0 ∣ a
hre : 0.re = 0
him : 0.im = 0
⊢ False

tactic: simp [hdvd, zero_im, zero_re, not_isCoprime_zero_zero] at hcoprime
state_before: case nonzero.intro
d : ℤ
a : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : a = 0
hre : 0.re = 0
him : 0.im = 0
⊢ False

tactic: simp only [ext, hre, eq_self_iff_true, zero_im, him, and_self_iff, zero_re]
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
hre : b.re = 0
him : b.im = 0
⊢ b = 0

tactic: rintro z hz - hzdvdu hzdvdv
state_before: case H
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
⊢ ∀ (z : ℤ), z ∈ nonunits ℤ → z ≠ 0 → z ∣ b.re → ¬z ∣ b.im

tactic: apply hz
state_before: case H
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ False

tactic: obtain ⟨ha, hb⟩ : z ∣ a.re ∧ z ∣ a.im := by
  rw [← coe_int_dvd_iff]
  apply dvd_trans _ hdvd
  rw [coe_int_dvd_iff]
  exact ⟨hzdvdu, hzdvdv⟩
state_before: case H
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ IsUnit z

tactic: exact hcoprime.isUnit_of_dvd' ha hb
state_before: case H.intro
d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
ha : z ∣ a.re
hb : z ∣ a.im
⊢ IsUnit z

tactic: rw [← coe_int_dvd_iff]
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ z ∣ a.re ∧ z ∣ a.im

tactic: apply dvd_trans _ hdvd
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ ↑z ∣ a

tactic: rw [coe_int_dvd_iff]
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ ↑z ∣ b

tactic: exact ⟨hzdvdu, hzdvdv⟩
state_before: d : ℤ
a b : ℤ√d
hcoprime : IsCoprime a.re a.im
hdvd : b ∣ a
z : ℤ
hz : z ∈ nonunits ℤ
hzdvdu : z ∣ b.re
hzdvdv : z ∣ b.im
⊢ z ∣ b.re ∧ z ∣ b.im
Theorem: Asymptotics.isTheta_of_norm_eventuallyEq
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simpa only [one_mul] using h.le
state_before: α : Type u_1
β : Type ?u.23422
E : Type u_2
F : Type u_3
G : Type ?u.23431
E' : Type ?u.23434
F' : Type ?u.23437
G' : Type ?u.23440
E'' : Type ?u.23443
F'' : Type ?u.23446
G'' : Type ?u.23449
R : Type ?u.23452
R' : Type ?u.23455
𝕜 : Type ?u.23458
𝕜' : Type ?u.23461
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
h : (fun x => ‖f x‖) =ᶠ[l] fun x => ‖g x‖
⊢ ∀ᶠ (x : α) in l, ‖f x‖ ≤ 1 * ‖g x‖

tactic: simpa only [one_mul] using h.symm.le
state_before: α : Type u_1
β : Type ?u.23422
E : Type u_2
F : Type u_3
G : Type ?u.23431
E' : Type ?u.23434
F' : Type ?u.23437
G' : Type ?u.23440
E'' : Type ?u.23443
F'' : Type ?u.23446
G'' : Type ?u.23449
R : Type ?u.23452
R' : Type ?u.23455
𝕜 : Type ?u.23458
𝕜' : Type ?u.23461
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
h : (fun x => ‖f x‖) =ᶠ[l] fun x => ‖g x‖
⊢ ∀ᶠ (x : α) in l, ‖g x‖ ≤ 1 * ‖f x‖
Theorem: CategoryTheory.cokernel_zero_of_nonzero_to_simple
File: Mathlib/CategoryTheory/Simple.lean

tactic: classical
  by_contra h
  haveI := isIso_of_epi_of_nonzero h
  exact w (eq_zero_of_mono_cokernel f)
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
X Y : C
inst✝ : Simple Y
f : X ⟶ Y
w : f ≠ 0
⊢ cokernel.π f = 0

tactic: by_contra h
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
X Y : C
inst✝ : Simple Y
f : X ⟶ Y
w : f ≠ 0
⊢ cokernel.π f = 0

tactic: haveI := isIso_of_epi_of_nonzero h
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
X Y : C
inst✝ : Simple Y
f : X ⟶ Y
w : f ≠ 0
h : ¬cokernel.π f = 0
⊢ False

tactic: exact w (eq_zero_of_mono_cokernel f)
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
X Y : C
inst✝ : Simple Y
f : X ⟶ Y
w : f ≠ 0
h : ¬cokernel.π f = 0
this : IsIso (cokernel.π f)
⊢ False
Theorem: SymOptionSuccEquiv.encode_decode
File: Mathlib/Data/Sym/Basic.lean

tactic: obtain s | s := s
state_before: α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym (Option α) n ⊕ Sym α (Nat.succ n)
⊢ encode (decode s) = s

tactic: simp
state_before: case inl
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym (Option α) n
⊢ encode (decode (Sum.inl s)) = Sum.inl s

tactic: unfold SymOptionSuccEquiv.encode
state_before: case inr
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
⊢ encode (decode (Sum.inr s)) = Sum.inr s

tactic: split_ifs with h
state_before: case inr
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
⊢ (if h : none ∈ decode (Sum.inr s) then Sum.inl (erase (decode (Sum.inr s)) none h)
    else Sum.inr (map (fun o => Option.get ↑o (_ : Option.isSome ↑o = true)) (attach (decode (Sum.inr s))))) =
    Sum.inr s

tactic: obtain ⟨a, _, ha⟩ := Multiset.mem_map.mp h
state_before: case inr.inl
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : none ∈ decode (Sum.inr s)
⊢ False

tactic: exact Option.some_ne_none _ ha
state_before: case inr.inl.intro.intro
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : none ∈ decode (Sum.inr s)
a : α
left✝ : a ∈ ↑s
ha : ↑Embedding.some a = none
⊢ False

tactic: refine' congr_arg Sum.inr _
state_before: case inr.inr
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ Sum.inr (map (fun o => Option.get ↑o (_ : Option.isSome ↑o = true)) (attach (decode (Sum.inr s)))) = Sum.inr s

tactic: refine' map_injective (Option.some_injective _) _ _
state_before: case inr.inr
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ map (fun o => Option.get ↑o (_ : Option.isSome ↑o = true)) (attach (decode (Sum.inr s))) = s

tactic: refine' Eq.trans _ (Eq.trans (SymOptionSuccEquiv.decode (Sum.inr s)).attach_map_coe _)
state_before: case inr.inr
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ map some (map (fun o => Option.get ↑o (_ : Option.isSome ↑o = true)) (attach (decode (Sum.inr s)))) = map some s

tactic: simp
state_before: case inr.inr.refine'_1
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ map some (map (fun o => Option.get ↑o (_ : Option.isSome ↑o = true)) (attach (decode (Sum.inr s)))) =
    map Subtype.val (attach (decode (Sum.inr s)))

case inr.inr.refine'_2
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ decode (Sum.inr s) = map some s

tactic: simp
state_before: case inr.inr.refine'_2
α : Type u_1
n : ℕ
inst✝ : DecidableEq α
s : Sym α (Nat.succ n)
h : ¬none ∈ decode (Sum.inr s)
⊢ decode (Sum.inr s) = map some s
Theorem: Polynomial.map_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [← map_cyclotomic_int n R, ← map_cyclotomic_int n S, map_map]
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map f (cyclotomic n R) = cyclotomic n S

tactic: congr!
state_before: n : ℕ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ map (RingHom.comp f (Int.castRingHom R)) (cyclotomic n ℤ) = map (Int.castRingHom S) (cyclotomic n ℤ)
Theorem: norm_pos_iff'''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← not_le, norm_le_zero_iff''']
state_before: 𝓕 : Type ?u.501471
𝕜 : Type ?u.501474
α : Type ?u.501477
ι : Type ?u.501480
κ : Type ?u.501483
E : Type u_1
F : Type ?u.501489
G : Type ?u.501492
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : T0Space E
a : E
⊢ 0 < ‖a‖ ↔ a ≠ 1
Theorem: Fin.mem_find_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rintro ⟨hpi, hj⟩
state_before: m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
⊢ (p i ∧ ∀ (j : Fin n), p j → i ≤ j) → i ∈ find p

tactic: cases hfp : Fin.find p
state_before: case intro
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
⊢ i ∈ find p

tactic: rw [find_eq_none_iff] at hfp
state_before: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : find p = none
⊢ i ∈ none

tactic: exact (hfp _ hpi).elim
state_before: case intro.none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
hfp : ∀ (i : Fin n), ¬p i
⊢ i ∈ none

tactic: exact Option.some_inj.2 (le_antisymm (find_min' hfp hpi) (hj _ (find_spec _ hfp)))
state_before: case intro.some
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
i : Fin n
hpi : p i
hj : ∀ (j : Fin n), p j → i ≤ j
val✝ : Fin n
hfp : find p = some val✝
⊢ i ∈ some val✝
Theorem: eq_mul_inv_of_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm]
state_before: α : Type ?u.49889
β : Type ?u.49892
G : Type u_1
inst✝ : Group G
a b c d : G
h : a * c = b
⊢ a = b * c⁻¹
Theorem: Finset.erase_cons
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [cons_eq_insert, erase_insert_eq_erase, erase_eq_of_not_mem h]
state_before: α : Type u_1
β : Type ?u.216030
γ : Type ?u.216033
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b : α
s : Finset α
a : α
h : ¬a ∈ s
⊢ erase (cons a s h) a = s
Theorem: Linarith.eq_of_eq_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simp [*]
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a = 0
hb : b = 0
⊢ a + b = 0
Theorem: BoxIntegral.Prepartition.mem_split_iff'
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp [mem_split_iff, ← Box.withBotCoe_inj]
state_before: ι : Type u_1
M : Type ?u.25531
n : ℕ
I J : Box ι
i : ι
x : ℝ
⊢ J ∈ split I i x ↔ ↑J = ↑I ∩ {y | y i ≤ x} ∨ ↑J = ↑I ∩ {y | x < y i}
Theorem: MeasureTheory.Measure.withDensityᵥ_absolutelyContinuous
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
⊢ withDensityᵥ μ f ≪ᵥ toENNRealVectorMeasure μ

tactic: refine' VectorMeasure.AbsolutelyContinuous.mk fun i hi₁ hi₂ => _
state_before: case pos
α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
hf : Integrable f
⊢ withDensityᵥ μ f ≪ᵥ toENNRealVectorMeasure μ

tactic: rw [toENNRealVectorMeasure_apply_measurable hi₁] at hi₂
state_before: case pos
α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
hf : Integrable f
i : Set α
hi₁ : MeasurableSet i
hi₂ : ↑(toENNRealVectorMeasure μ) i = 0
⊢ ↑(withDensityᵥ μ f) i = 0

tactic: rw [withDensityᵥ_apply hf hi₁, Measure.restrict_zero_set hi₂, integral_zero_measure]
state_before: case pos
α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
hf : Integrable f
i : Set α
hi₁ : MeasurableSet i
hi₂ : ↑↑μ i = 0
⊢ ↑(withDensityᵥ μ f) i = 0

tactic: rw [withDensityᵥ, dif_neg hf]
state_before: case neg
α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
hf : ¬Integrable f
⊢ withDensityᵥ μ f ≪ᵥ toENNRealVectorMeasure μ

tactic: exact VectorMeasure.AbsolutelyContinuous.zero _
state_before: case neg
α : Type u_1
β : Type ?u.59120
m : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.59139
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
μ : Measure α
f : α → ℝ
hf : ¬Integrable f
⊢ 0 ≪ᵥ toENNRealVectorMeasure μ
Theorem: Nat.pow_dvd_pow_iff_pow_le_pow
File: Mathlib/Data/Nat/Pow.lean

tactic: constructor
state_before: k l x : ℕ
w : 0 < x + 1
⊢ (x + 1) ^ k ∣ (x + 1) ^ l ↔ (x + 1) ^ k ≤ (x + 1) ^ l

tactic: intro a
state_before: case mp
k l x : ℕ
w : 0 < x + 1
⊢ (x + 1) ^ k ∣ (x + 1) ^ l → (x + 1) ^ k ≤ (x + 1) ^ l

tactic: exact le_of_dvd (pow_pos (succ_pos x) l) a
state_before: case mp
k l x : ℕ
w : 0 < x + 1
a : (x + 1) ^ k ∣ (x + 1) ^ l
⊢ (x + 1) ^ k ≤ (x + 1) ^ l

tactic: intro a
state_before: case mpr
k l x : ℕ
w : 0 < x + 1
⊢ (x + 1) ^ k ≤ (x + 1) ^ l → (x + 1) ^ k ∣ (x + 1) ^ l

tactic: cases' x with x
state_before: case mpr
k l x : ℕ
w : 0 < x + 1
a : (x + 1) ^ k ≤ (x + 1) ^ l
⊢ (x + 1) ^ k ∣ (x + 1) ^ l

tactic: simp
state_before: case mpr.zero
k l : ℕ
w : 0 < zero + 1
a : (zero + 1) ^ k ≤ (zero + 1) ^ l
⊢ (zero + 1) ^ k ∣ (zero + 1) ^ l

tactic: have le := (pow_le_iff_le_right (Nat.le_add_left _ _)).mp a
state_before: case mpr.succ
k l x : ℕ
w : 0 < succ x + 1
a : (succ x + 1) ^ k ≤ (succ x + 1) ^ l
⊢ (succ x + 1) ^ k ∣ (succ x + 1) ^ l

tactic: use (x + 2) ^ (l - k)
state_before: case mpr.succ
k l x : ℕ
w : 0 < succ x + 1
a : (succ x + 1) ^ k ≤ (succ x + 1) ^ l
le : k ≤ l
⊢ (succ x + 1) ^ k ∣ (succ x + 1) ^ l

tactic: rw [← pow_add, add_comm k, tsub_add_cancel_of_le le]
state_before: case mpr.succ
k l x : ℕ
w : 0 < succ x + 1
a : (succ x + 1) ^ k ≤ (succ x + 1) ^ l
le : k ≤ l
⊢ (succ x + 1) ^ l = (succ x + 1) ^ k * (x + 2) ^ (l - k)
Theorem: AlgEquiv.arrowCongr_trans
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₂
e₁' : A₁' ≃ₐ[R] A₂'
e₂ : A₂ ≃ₐ[R] A₃
e₂' : A₂' ≃ₐ[R] A₃'
⊢ arrowCongr (trans e₁ e₂) (trans e₁' e₂') = (arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂')

tactic: rfl
state_before: case H.H
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₂
e₁' : A₁' ≃ₐ[R] A₂'
e₂ : A₂ ≃ₐ[R] A₃
e₂' : A₂' ≃ₐ[R] A₃'
x✝¹ : A₁ →ₐ[R] A₁'
x✝ : A₃
⊢ ↑(↑(arrowCongr (trans e₁ e₂) (trans e₁' e₂')) x✝¹) x✝ = ↑(↑((arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂')) x✝¹) x✝
Theorem: AlgebraicTopology.DoldKan.P_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: ext n
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ P q ≫ P q = P q

tactic: exact P_f_idem q n
state_before: case h
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ HomologicalComplex.Hom.f (P q ≫ P q) n = HomologicalComplex.Hom.f (P q) n
Theorem: Basis.sum_equivFun
File: Mathlib/LinearAlgebra/Basis.lean

tactic: conv_rhs => rw [← b.total_repr u]
state_before: ι : Type u_2
ι' : Type ?u.659117
R : Type u_3
R₂ : Type ?u.659123
K : Type ?u.659126
M : Type u_1
M' : Type ?u.659132
M'' : Type ?u.659135
V : Type u
V' : Type ?u.659140
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
u : M
⊢ ∑ i : ι, ↑(equivFun b) u i • ↑b i = u

tactic: simp [Finsupp.total_apply, Finsupp.sum_fintype, b.equivFun_apply]
state_before: ι : Type u_2
ι' : Type ?u.659117
R : Type u_3
R₂ : Type ?u.659123
K : Type ?u.659126
M : Type u_1
M' : Type ?u.659132
M'' : Type ?u.659135
V : Type u
V' : Type ?u.659140
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
u : M
⊢ ∑ i : ι, ↑(equivFun b) u i • ↑b i = ↑(Finsupp.total ι M R ↑b) (↑b.repr u)
Theorem: AddCommGroup.neg_modEq_neg
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, neg_add_eq_sub]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ -b ≡ -a [PMOD p] ↔ a ≡ b [PMOD p]
Theorem: Int.floor_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← cast_one, floor_intCast]
state_before: F : Type ?u.128362
α : Type u_1
β : Type ?u.128368
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊1⌋ = 1
Theorem: Filter.eventually_smallSets
File: Mathlib/Order/Filter/SmallSets.lean

tactic: rw [smallSets, eventually_lift'_iff]
state_before: α : Type u_1
β : Type ?u.1327
ι : Sort ?u.1330
l l' la : Filter α
lb : Filter β
p : Set α → Prop
⊢ (∀ᶠ (s : Set α) in smallSets l, p s) ↔ ∃ s, s ∈ l ∧ ∀ (t : Set α), t ⊆ s → p t

tactic: rfl
state_before: α : Type u_1
β : Type ?u.1327
ι : Sort ?u.1330
l l' la : Filter α
lb : Filter β
p : Set α → Prop
⊢ (∃ t, t ∈ l ∧ ∀ (y : Set α), y ∈ 𝒫 t → p y) ↔ ∃ s, s ∈ l ∧ ∀ (t : Set α), t ⊆ s → p t

case hh
α : Type u_1
β : Type ?u.1327
ι : Sort ?u.1330
l l' la : Filter α
lb : Filter β
p : Set α → Prop
⊢ Monotone powerset

tactic: exact monotone_powerset
state_before: case hh
α : Type u_1
β : Type ?u.1327
ι : Sort ?u.1330
l l' la : Filter α
lb : Filter β
p : Set α → Prop
⊢ Monotone powerset