tasksource/leandojo huggingface dataset:
Theorem: Real.toNNReal_eq_nnnorm_of_nonneg
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [Real.toNNReal_of_nonneg hr]
state_before: 𝓕 : Type ?u.1109488
𝕜 : Type ?u.1109491
α : Type ?u.1109494
ι : Type ?u.1109497
κ : Type ?u.1109500
E : Type ?u.1109503
F : Type ?u.1109506
G : Type ?u.1109509
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ toNNReal r = ‖r‖₊

tactic: ext
state_before: 𝓕 : Type ?u.1109488
𝕜 : Type ?u.1109491
α : Type ?u.1109494
ι : Type ?u.1109497
κ : Type ?u.1109500
E : Type ?u.1109503
F : Type ?u.1109506
G : Type ?u.1109509
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ { val := r, property := hr } = ‖r‖₊

tactic: rw [coe_mk, coe_nnnorm r, Real.norm_eq_abs r, abs_of_nonneg hr]
state_before: case a
𝓕 : Type ?u.1109488
𝕜 : Type ?u.1109491
α : Type ?u.1109494
ι : Type ?u.1109497
κ : Type ?u.1109500
E : Type ?u.1109503
F : Type ?u.1109506
G : Type ?u.1109509
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ↑{ val := r, property := hr } = ↑‖r‖₊
Theorem: RegularExpression.map_map
File: Mathlib/Computability/RegularExpressions.lean

tactic: simp only [map, Function.comp_apply, map_map]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R S : RegularExpression α
⊢ map g (map f (R + S)) = map (g ∘ f) (R + S)

tactic: simp only [map, Function.comp_apply, map_map]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R S : RegularExpression α
⊢ map g (map f (R * S)) = map (g ∘ f) (R * S)

tactic: simp only [map, Function.comp_apply, map_map]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R : RegularExpression α
⊢ map g (map f (star R)) = map (g ∘ f) (star R)
Theorem: Submodule.sub_mem_iff_left
File: Mathlib/Algebra/Module/Submodule/Basic.lean

tactic: rw [sub_eq_add_neg, p.add_mem_iff_left (p.neg_mem hy)]
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝¹ : Ring R
inst✝ : AddCommGroup M
module_M : Module R M
p p' : Submodule R M
r : R
x y : M
hy : y ∈ p
⊢ x - y ∈ p ↔ x ∈ p
Theorem: Order.succ_lt_succ_iff_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
hb : ¬IsMax b
⊢ succ a < succ b ↔ a < b
Theorem: EReal.abs_zero
File: Mathlib/Data/Real/EReal.lean

tactic: rw [abs_eq_zero_iff]
state_before: ⊢ EReal.abs 0 = 0
Theorem: Matrix.fromBlocks_mulVec
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i
state_before: l : Type u_1
m : Type u_2
n : Type u_4
o : Type u_5
p : Type ?u.43962
q : Type ?u.43965
m' : o → Type ?u.43970
n' : o → Type ?u.43975
p' : o → Type ?u.43980
R : Type ?u.43983
S : Type ?u.43986
α : Type u_3
β : Type ?u.43992
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : l ⊕ m → α
⊢ mulVec (fromBlocks A B C D) x =
    Sum.elim (mulVec A (x ∘ Sum.inl) + mulVec B (x ∘ Sum.inr)) (mulVec C (x ∘ Sum.inl) + mulVec D (x ∘ Sum.inr))

tactic: cases i <;> simp [mulVec, dotProduct]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_4
o : Type u_5
p : Type ?u.43962
q : Type ?u.43965
m' : o → Type ?u.43970
n' : o → Type ?u.43975
p' : o → Type ?u.43980
R : Type ?u.43983
S : Type ?u.43986
α : Type u_3
β : Type ?u.43992
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : l ⊕ m → α
i : n ⊕ o
⊢ mulVec (fromBlocks A B C D) x i =
    Sum.elim (mulVec A (x ∘ Sum.inl) + mulVec B (x ∘ Sum.inr)) (mulVec C (x ∘ Sum.inl) + mulVec D (x ∘ Sum.inr)) i
Theorem: CategoryTheory.Idempotents.Karoubi.comp_proof
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rw [assoc, comp_p, ← assoc, p_comp]
state_before: C : Type u_1
inst✝ : Category C
P Q R : Karoubi C
g : Hom Q R
f : Hom P Q
⊢ f.f ≫ g.f = P.p ≫ (f.f ≫ g.f) ≫ R.p
Theorem: Hyperreal.infinitePos_iff_infinitesimal_inv_pos
File: Mathlib/Data/Real/Hyperreal.lean

tactic: convert hip r⁻¹
state_before: x : ℝ*
hip : InfinitePos x
r : ℝ
hr : 0 < r
⊢ (↑r)⁻¹ < x
Theorem: Int.dvd_lcm_left
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i j : ℤ
⊢ i ∣ ↑(lcm i j)

tactic: apply coe_nat_dvd_right.mpr
state_before: i j : ℤ
⊢ i ∣ ↑(Nat.lcm (natAbs i) (natAbs j))

tactic: apply Nat.dvd_lcm_left
state_before: i j : ℤ
⊢ natAbs i ∣ Nat.lcm (natAbs i) (natAbs j)
Theorem: AddMonoidAlgebra.finiteType_iff_group_fg
File: Mathlib/RingTheory/FiniteType.lean

tactic: simpa [AddGroup.fg_iff_addMonoid_fg] using finiteType_iff_fg
state_before: R : Type u_2
M : Type ?u.314374
inst✝³ : AddCommMonoid M
G : Type u_1
inst✝² : AddCommGroup G
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ FiniteType R (AddMonoidAlgebra R G) ↔ AddGroup.FG G
Theorem: Array.size_mk
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp [size]
state_before: α : Type u_1
as : List α
⊢ size { data := as } = List.length as
Theorem: div_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_le_iff hb, one_mul]
state_before: ι : Type ?u.75667
α : Type u_1
β : Type ?u.75673
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ a / b ≤ 1 ↔ a ≤ b
Theorem: Real.dist_right_le_of_mem_uIcc
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa only [dist_comm _ z] using abs_sub_right_of_mem_uIcc h
state_before: α : Type u
β : Type v
X : Type ?u.195195
ι : Type ?u.195198
inst✝ : PseudoMetricSpace α
x y z : ℝ
h : y ∈ uIcc x z
⊢ dist y z ≤ dist x z
Theorem: Polynomial.mul_X_pow_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction' k with k ih
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]
k : ℕ
⊢ comp (p * X ^ k) r = comp p r * r ^ k

tactic: simp
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (p * X ^ Nat.zero) r = comp p r * r ^ Nat.zero

tactic: simp [ih, pow_succ', ← mul_assoc, mul_X_comp]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
k : ℕ
ih : comp (p * X ^ k) r = comp p r * r ^ k
⊢ comp (p * X ^ Nat.succ k) r = comp p r * r ^ Nat.succ k
Theorem: Prime.dvd_prod_iff
File: Mathlib/Data/List/Prime.lean

tactic: constructor
state_before: M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
⊢ p ∣ prod L ↔ ∃ a, a ∈ L ∧ p ∣ a

tactic: intro h
state_before: case mp
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
⊢ p ∣ prod L → ∃ a, a ∈ L ∧ p ∣ a

tactic: induction' L with L_hd L_tl L_ih
state_before: case mp
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h : p ∣ prod L
⊢ ∃ a, a ∈ L ∧ p ∣ a

tactic: rw [prod_nil] at h
state_before: case mp.nil
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
h : p ∣ prod []
⊢ ∃ a, a ∈ [] ∧ p ∣ a

tactic: exact absurd h pp.not_dvd_one
state_before: case mp.nil
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
h : p ∣ 1
⊢ ∃ a, a ∈ [] ∧ p ∣ a

tactic: rw [prod_cons] at h
state_before: case mp.cons
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
L_hd : M
L_tl : List M
L_ih : p ∣ prod L_tl → ∃ a, a ∈ L_tl ∧ p ∣ a
h : p ∣ prod (L_hd :: L_tl)
⊢ ∃ a, a ∈ L_hd :: L_tl ∧ p ∣ a

tactic: cases' pp.dvd_or_dvd h with hd hd
state_before: case mp.cons
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
L_hd : M
L_tl : List M
L_ih : p ∣ prod L_tl → ∃ a, a ∈ L_tl ∧ p ∣ a
h : p ∣ L_hd * prod L_tl
⊢ ∃ a, a ∈ L_hd :: L_tl ∧ p ∣ a

tactic: exact ⟨L_hd, mem_cons_self L_hd L_tl, hd⟩
state_before: case mp.cons.inl
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
L_hd : M
L_tl : List M
L_ih : p ∣ prod L_tl → ∃ a, a ∈ L_tl ∧ p ∣ a
h : p ∣ L_hd * prod L_tl
hd : p ∣ L_hd
⊢ ∃ a, a ∈ L_hd :: L_tl ∧ p ∣ a

tactic: obtain ⟨x, hx1, hx2⟩ := L_ih hd
state_before: case mp.cons.inr
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
L_hd : M
L_tl : List M
L_ih : p ∣ prod L_tl → ∃ a, a ∈ L_tl ∧ p ∣ a
h : p ∣ L_hd * prod L_tl
hd : p ∣ prod L_tl
⊢ ∃ a, a ∈ L_hd :: L_tl ∧ p ∣ a

tactic: exact ⟨x, mem_cons_of_mem L_hd hx1, hx2⟩
state_before: case mp.cons.inr.intro.intro
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
h✝ : p ∣ prod L
L_hd : M
L_tl : List M
L_ih : p ∣ prod L_tl → ∃ a, a ∈ L_tl ∧ p ∣ a
h : p ∣ L_hd * prod L_tl
hd : p ∣ prod L_tl
x : M
hx1 : x ∈ L_tl
hx2 : p ∣ x
⊢ ∃ a, a ∈ L_hd :: L_tl ∧ p ∣ a

tactic: exact fun ⟨a, ha1, ha2⟩ => dvd_trans ha2 (dvd_prod ha1)
state_before: case mpr
M : Type u_1
inst✝ : CommMonoidWithZero M
p : M
L : List M
pp : Prime p
⊢ (∃ a, a ∈ L ∧ p ∣ a) → p ∣ prod L
Theorem: List.Pairwise.chain
File: Std/Data/List/Lemmas.lean

tactic: let ⟨r, p'⟩ := pairwise_cons.1 p
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
a : α✝
l : List α✝
p : Pairwise R (a :: l)
⊢ Chain R a l

tactic: clear p
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
a : α✝
l : List α✝
p : Pairwise R (a :: l)
r : ∀ (a' : α✝), a' ∈ l → R a a'
p' : Pairwise R l
⊢ Chain R a l

tactic: induction p' generalizing a with
| nil => exact Chain.nil
| @cons b l r' _ IH =>
  simp only [chain_cons, forall_mem_cons] at r
  exact chain_cons.2 ⟨r.1, IH r'⟩
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
a : α✝
l : List α✝
r : ∀ (a' : α✝), a' ∈ l → R a a'
p' : Pairwise R l
⊢ Chain R a l

tactic: exact Chain.nil
state_before: case nil
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
a : α✝
r : ∀ (a' : α✝), a' ∈ [] → R a a'
⊢ Chain R a []

tactic: simp only [chain_cons, forall_mem_cons] at r
state_before: case cons
α✝ : Type u_1
R : α✝ → α✝ → Prop
l✝ : List α✝
b : α✝
l : List α✝
r' : ∀ (a' : α✝), a' ∈ l → R b a'
a✝ : Pairwise R l
IH : ∀ {a : α✝}, (∀ (a' : α✝), a' ∈ l → R a a') → Chain R a l
a : α✝
r : ∀ (a' : α✝), a' ∈ b :: l → R a a'
⊢ Chain R a (b :: l)

tactic: exact chain_cons.2 ⟨r.1, IH r'⟩
state_before: case cons
α✝ : Type u_1
R : α✝ → α✝ → Prop
l✝ : List α✝
b : α✝
l : List α✝
r' : ∀ (a' : α✝), a' ∈ l → R b a'
a✝ : Pairwise R l
IH : ∀ {a : α✝}, (∀ (a' : α✝), a' ∈ l → R a a') → Chain R a l
a : α✝
r : R a b ∧ ∀ (x : α✝), x ∈ l → R a x
⊢ Chain R a (b :: l)
Theorem: Polynomial.roots_multiset_prod_X_sub_C
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [roots_multiset_prod, Multiset.bind_map]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ roots (prod (Multiset.map (fun a => X - ↑C a) s)) = s

tactic: simp_rw [roots_X_sub_C]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (Multiset.bind s fun a => roots (X - ↑C a)) = s

tactic: rw [Multiset.bind_singleton, Multiset.map_id']
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (Multiset.bind s fun a => {a}) = s

tactic: rw [Multiset.mem_map]
state_before: case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ ¬0 ∈ Multiset.map (fun a => X - ↑C a) s

tactic: rintro ⟨a, -, h⟩
state_before: case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ ¬∃ a, a ∈ s ∧ X - ↑C a = 0

tactic: exact X_sub_C_ne_zero a h
state_before: case a.intro.intro
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
a : R
h : X - ↑C a = 0
⊢ False
Theorem: Polynomial.leadingCoeff_C_mul_X_pow
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [C_mul_X_pow_eq_monomial, leadingCoeff_monomial]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.604744
a : R
n : ℕ
⊢ leadingCoeff (↑C a * X ^ n) = a
Theorem: IsIdempotentElem.mul_of_commute
File: Mathlib/Algebra/Ring/Idempotents.lean

tactic: rw [IsIdempotentElem, mul_assoc, ← mul_assoc q, ← h.eq, mul_assoc p, h₂.eq, ← mul_assoc, h₁.eq]
state_before: M : Type ?u.482
N : Type ?u.485
S : Type u_1
M₀ : Type ?u.491
M₁ : Type ?u.494
R : Type ?u.497
G : Type ?u.500
G₀ : Type ?u.503
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p q : S
h : Commute p q
h₁ : IsIdempotentElem p
h₂ : IsIdempotentElem q
⊢ IsIdempotentElem (p * q)
Theorem: List.count_cons
File: Mathlib/Data/List/Count.lean

tactic: simp [count_cons']
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
l : List α
⊢ count a (b :: l) = if a = b then succ (count a l) else count a l

tactic: split_ifs <;> rfl
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
l : List α
⊢ (count a l + if a = b then 1 else 0) = if a = b then succ (count a l) else count a l
Theorem: CircleDeg1Lift.commute_int_add
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [add_comm _ (n : ℝ)] using f.commute_add_int n
state_before: f g : CircleDeg1Lift
n : ℤ
⊢ Function.Commute ↑f fun x => ↑n + x
Theorem: WittVector.mapFun.add
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.80564
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.80579
β : Type ?u.80582
f : R →+* S
x y : 𝕎 R
⊢ mapFun (↑f) (x + y) = mapFun (↑f) x + mapFun (↑f) y
Theorem: ConvexBody.hausdorffEdist_coe
File: Mathlib/Analysis/Convex/Body.lean

tactic: rw [edist_dist]
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L = edist K L

tactic: exact (ENNReal.ofReal_toReal hausdorffEdist_ne_top).symm
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L = ENNReal.ofReal (dist K L)
Theorem: Real.Angle.tan_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: conv_rhs => rw [← coe_toReal θ, tan_coe]
state_before: θ : Angle
⊢ Real.tan (toReal θ) = tan θ
Theorem: List.find?_mem
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with b l IH
state_before: ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
a : α
H : find? p l = some a
⊢ a ∈ l

tactic: by_cases h : p b
state_before: case cons
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H✝ : find? p l✝ = some a
b : α
l : List α
IH : find? p l = some a → a ∈ l
H : find? p (b :: l) = some a
⊢ a ∈ b :: l

tactic: contradiction
state_before: case nil
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
a : α
H✝ : find? p l = some a
H : find? p [] = some a
⊢ a ∈ []

tactic: rw [find?_cons_of_pos _ h] at H
state_before: case pos
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H✝ : find? p l✝ = some a
b : α
l : List α
IH : find? p l = some a → a ∈ l
H : find? p (b :: l) = some a
h : p b = true
⊢ a ∈ b :: l

tactic: cases H
state_before: case pos
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H✝ : find? p l✝ = some a
b : α
l : List α
IH : find? p l = some a → a ∈ l
H : some b = some a
h : p b = true
⊢ a ∈ b :: l

tactic: apply mem_cons_self
state_before: case pos.refl
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H : find? p l✝ = some a
l : List α
IH : find? p l = some a → a ∈ l
h : p a = true
⊢ a ∈ a :: l

tactic: rw [find?_cons_of_neg _ h] at H
state_before: case neg
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H✝ : find? p l✝ = some a
b : α
l : List α
IH : find? p l = some a → a ∈ l
H : find? p (b :: l) = some a
h : ¬p b = true
⊢ a ∈ b :: l

tactic: exact mem_cons_of_mem _ (IH H)
state_before: case neg
ι : Type ?u.339715
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l✝ : List α
a : α
H✝ : find? p l✝ = some a
b : α
l : List α
IH : find? p l = some a → a ∈ l
H : find? p l = some a
h : ¬p b = true
⊢ a ∈ b :: l
Theorem: MeasureTheory.SignedMeasure.eq_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: set f' := hfi.1.mk f
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
⊢ f =ᶠ[ae μ] rnDeriv s μ

tactic: have hadd' : s = t + μ.withDensityᵥ f' := by
  convert hadd using 2
  exact WithDensityᵥEq.congr_ae hfi.1.ae_eq_mk.symm
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
⊢ f =ᶠ[ae μ] rnDeriv s μ

tactic: haveI := haveLebesgueDecomposition_mk μ hfi.1.measurable_mk htμ hadd'
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
hadd' : s = t + withDensityᵥ μ f'
⊢ f =ᶠ[ae μ] rnDeriv s μ

tactic: refine' (Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _) hfi _).symm
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
hadd' : s = t + withDensityᵥ μ f'
this : HaveLebesgueDecomposition s μ
⊢ f =ᶠ[ae μ] rnDeriv s μ

tactic: rw [← add_right_inj t, ← hadd, eq_singularPart _ f htμ hadd,
  singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
hadd' : s = t + withDensityᵥ μ f'
this : HaveLebesgueDecomposition s μ
⊢ withDensityᵥ μ (rnDeriv s μ) = withDensityᵥ μ f

tactic: convert hadd using 2
state_before: α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
⊢ s = t + withDensityᵥ μ f'

tactic: exact WithDensityᵥEq.congr_ae hfi.1.ae_eq_mk.symm
state_before: case h.e'_3.h.e'_6
α : Type u_1
β : Type ?u.641648
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
hfi : Integrable f
htμ : t ⟂ᵥ toENNRealVectorMeasure μ
hadd : s = t + withDensityᵥ μ f
f' : α → ℝ := AEStronglyMeasurable.mk f (_ : AEStronglyMeasurable f μ)
⊢ withDensityᵥ μ f' = withDensityᵥ μ f
Theorem: FirstOrder.Language.BoundedFormula.isPrenex_toPrenexImpRight
File: Mathlib/ModelTheory/Syntax.lean

tactic: induction' hψ with _ _ hψ _ _ _ ih1 _ _ _ ih2
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.127743
P : Type ?u.127746
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.127774
n l : ℕ
φ✝ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ : BoundedFormula L α n
hφ : IsQF φ
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImpRight φ ψ)

tactic: rw [hψ.toPrenexImpRight]
state_before: case of_isQF
L : Language
L' : Language
M : Type w
N : Type ?u.127743
P : Type ?u.127746
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.127774
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hψ : IsQF φ✝
φ : BoundedFormula L α n✝
hφ : IsQF φ
⊢ IsPrenex (toPrenexImpRight φ φ✝)

tactic: exact (hφ.imp hψ).isPrenex
state_before: case of_isQF
L : Language
L' : Language
M : Type w
N : Type ?u.127743
P : Type ?u.127746
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.127774
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hψ : IsQF φ✝
φ : BoundedFormula L α n✝
hφ : IsQF φ
⊢ IsPrenex (imp φ φ✝)

tactic: exact (ih1 hφ.liftAt).all
state_before: case all
L : Language
L' : Language
M : Type w
N : Type ?u.127743
P : Type ?u.127746
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.127774
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
h✝ : IsPrenex φ✝
ih1 : ∀ {φ : BoundedFormula L α (n✝ + 1)}, IsQF φ → IsPrenex (toPrenexImpRight φ φ✝)
φ : BoundedFormula L α n✝
hφ : IsQF φ
⊢ IsPrenex (toPrenexImpRight φ (all φ✝))

tactic: exact (ih2 hφ.liftAt).ex
state_before: case ex
L : Language
L' : Language
M : Type w
N : Type ?u.127743
P : Type ?u.127746
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.127774
n l : ℕ
φ✝² ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ✝¹ ψ : BoundedFormula L α n
hφ✝ : IsQF φ✝¹
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
h✝ : IsPrenex φ✝
ih2 : ∀ {φ : BoundedFormula L α (n✝ + 1)}, IsQF φ → IsPrenex (toPrenexImpRight φ φ✝)
φ : BoundedFormula L α n✝
hφ : IsQF φ
⊢ IsPrenex (toPrenexImpRight φ (BoundedFormula.ex φ✝))
Theorem: Polynomial.X_pow_sub_one_splits
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [splits_iff_card_roots, ← nthRoots, IsPrimitiveRoot.card_nthRoots h, natDegree_X_pow_sub_C]
state_before: K : Type u_1
inst✝ : Field K
ζ : K
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ Splits (RingHom.id K) (X ^ n - ↑C 1)
Theorem: Cardinal.mul_lt_of_lt
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [mul_eq_self h]
state_before: a b c : Cardinal
hc : ℵ₀ ≤ c
h1 : a < c
h2 : b < c
h : ℵ₀ ≤ max a b
⊢ max a b * max a b < c

tactic: exact max_lt h1 h2
state_before: a b c : Cardinal
hc : ℵ₀ ≤ c
h1 : a < c
h2 : b < c
h : ℵ₀ ≤ max a b
⊢ max a b < c
Theorem: Finset.Nonempty.zero_smul
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simpa [mem_smul] using ht
state_before: F : Type ?u.924314
α : Type u_2
β : Type u_1
γ : Type ?u.924323
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
ht : Finset.Nonempty t
⊢ 0 ⊆ 0 • t
Theorem: Set.mem_ite_empty_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : Set α
x : α
⊢ (∃ h, x ∈ t) ↔ p ∧ x ∈ t