tasksource/leandojo huggingface dataset:
Theorem: dvd_mul_sub_mul
File: Mathlib/Algebra/Ring/Divisibility.lean

tactic: convert dvd_add (hxy.mul_left a) (hab.mul_right y) using 1
state_before: α : Type u_1
β : Type ?u.14179
inst✝ : NonUnitalCommRing α
a✝ b✝ c k a b x y : α
hab : k ∣ a - b
hxy : k ∣ x - y
⊢ k ∣ a * x - b * y

tactic: rw [mul_sub_left_distrib, mul_sub_right_distrib]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.14179
inst✝ : NonUnitalCommRing α
a✝ b✝ c k a b x y : α
hab : k ∣ a - b
hxy : k ∣ x - y
⊢ a * x - b * y = a * (x - y) + (a - b) * y

tactic: simp only [sub_eq_add_neg, add_assoc, neg_add_cancel_left]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.14179
inst✝ : NonUnitalCommRing α
a✝ b✝ c k a b x y : α
hab : k ∣ a - b
hxy : k ∣ x - y
⊢ a * x - b * y = a * x - a * y + (a * y - b * y)
Theorem: Asymptotics.isBigO_one_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [isBigO_iff, norm_one, mul_one]
state_before: α : Type u_1
β : Type ?u.296904
E : Type u_2
F : Type u_3
G : Type ?u.296913
E' : Type ?u.296916
F' : Type ?u.296919
G' : Type ?u.296922
E'' : Type ?u.296925
F'' : Type ?u.296928
G'' : Type ?u.296931
R : Type ?u.296934
R' : Type ?u.296937
𝕜 : Type ?u.296940
𝕜' : Type ?u.296943
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''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (f =O[l] fun _x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖

tactic: rfl
state_before: α : Type u_1
β : Type ?u.296904
E : Type u_2
F : Type u_3
G : Type ?u.296913
E' : Type ?u.296916
F' : Type ?u.296919
G' : Type ?u.296922
E'' : Type ?u.296925
F'' : Type ?u.296928
G'' : Type ?u.296931
R : Type ?u.296934
R' : Type ?u.296937
𝕜 : Type ?u.296940
𝕜' : Type ?u.296943
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''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖
Theorem: Set.card_insert
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← card_fintypeInsertOfNotMem s h]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : ¬a ∈ s
d : Fintype ↑(insert a s)
⊢ Fintype.card ↑(insert a s) = Fintype.card ↑s + 1

tactic: congr
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : ¬a ∈ s
d : Fintype ↑(insert a s)
⊢ Fintype.card ↑(insert a s) = Fintype.card ↑(insert a s)

tactic: exact Subsingleton.elim _ _
state_before: case h.e_2.h
α : Type u
β : Type v
ι : Sort w
γ : Type x
a : α
s : Set α
inst✝ : Fintype ↑s
h : ¬a ∈ s
d : Fintype ↑(insert a s)
⊢ d = fintypeInsertOfNotMem s h
Theorem: RingQuot.mkRingHom_rel
File: Mathlib/Algebra/RingQuot.lean

tactic: simp [mkRingHom_def, Quot.sound (Rel.of w)]
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r✝ r : R → R → Prop
x y : R
w : r x y
⊢ ↑(mkRingHom r) x = ↑(mkRingHom r) y
Theorem: div_lt_div_left
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_lt_mul_left ha, inv_lt_inv hb hc]
state_before: ι : Type ?u.65810
α : Type u_1
β : Type ?u.65816
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
hc : 0 < c
⊢ a / b < a / c ↔ c < b
Theorem: Int.dvd_of_dvd_mul_left_of_gcd_one
File: Mathlib/Data/Int/GCD.lean

tactic: have := gcd_eq_gcd_ab a c
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
⊢ a ∣ b

tactic: simp only [hab, Int.ofNat_zero, Int.ofNat_succ, zero_add] at this
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
this : ↑(gcd a c) = a * gcdA a c + c * gcdB a c
⊢ a ∣ b

tactic: have : b * a * gcdA a c + b * c * gcdB a c = b := by simp [mul_assoc, ← mul_add, ← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
this : 1 = a * gcdA a c + c * gcdB a c
⊢ a ∣ b

tactic: rw [← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
this✝ : 1 = a * gcdA a c + c * gcdB a c
this : b * a * gcdA a c + b * c * gcdB a c = b
⊢ a ∣ b

tactic: exact dvd_add (dvd_mul_of_dvd_left (dvd_mul_left a b) _) (dvd_mul_of_dvd_left habc _)
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
this✝ : 1 = a * gcdA a c + c * gcdB a c
this : b * a * gcdA a c + b * c * gcdB a c = b
⊢ a ∣ b * a * gcdA a c + b * c * gcdB a c

tactic: simp [mul_assoc, ← mul_add, ← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : gcd a c = 1
this : 1 = a * gcdA a c + c * gcdB a c
⊢ b * a * gcdA a c + b * c * gcdB a c = b
Theorem: List.length_reverse
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => rfl
| cons a as ih => simp [ih]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
⊢ length (reverse as) = length as

tactic: rfl
state_before: case nil
α : Type u
β : Type v
γ : Type w
⊢ length (reverse nil) = length nil

tactic: simp [ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
as : List α
ih : length (reverse as) = length as
⊢ length (reverse (a :: as)) = length (a :: as)
Theorem: mul_inv_le_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, inv_mul_le_iff' h]
state_before: ι : Type ?u.33547
α : Type u_1
β : Type ?u.33553
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a * b⁻¹ ≤ c ↔ a ≤ c * b
Theorem: QuaternionAlgebra.Basis.lift_smul
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp [lift, mul_smul, ← Algebra.smul_def]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.109263
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
r : R
x : ℍ[R,c₁,c₂]
⊢ lift q (r • x) = r • lift q x
Theorem: Finset.weightedVSubOfPoint_sdiff
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubOfPoint_apply, sum_sdiff h]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.111150
s₂✝ : Finset ι₂
inst✝ : DecidableEq ι
s₂ : Finset ι
h : s₂ ⊆ s
w : ι → k
p : ι → P
b : P
⊢ ↑(weightedVSubOfPoint (s \ s₂) p b) w + ↑(weightedVSubOfPoint s₂ p b) w = ↑(weightedVSubOfPoint s p b) w
Theorem: Equiv.Perm.IsCycleOn.countable
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain rfl | ⟨a, ha⟩ := s.eq_empty_or_nonempty
state_before: ι : Type ?u.2072778
α : Type u_1
β : Type ?u.2072784
f g : Perm α
s t : Set α
a b x y : α
hs : IsCycleOn f s
⊢ Set.Countable s

tactic: exact Set.countable_empty
state_before: case inl
ι : Type ?u.2072778
α : Type u_1
β : Type ?u.2072784
f g : Perm α
t : Set α
a b x y : α
hs : IsCycleOn f ∅
⊢ Set.Countable ∅

tactic: exact (Set.countable_range fun n : ℤ => (⇑(f ^ n) : α → α) a).mono (hs.2 ha)
state_before: case inr.intro
ι : Type ?u.2072778
α : Type u_1
β : Type ?u.2072784
f g : Perm α
s t : Set α
a✝ b x y : α
hs : IsCycleOn f s
a : α
ha : a ∈ s
⊢ Set.Countable s
Theorem: MeasureTheory.SimpleFunc.exists_range_iff
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simpa only [mem_range, exists_prop] using Set.exists_range_iff
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12684
δ : Type ?u.12687
inst✝ : MeasurableSpace α
f : α →ₛ β
p : β → Prop
⊢ (∃ y, y ∈ SimpleFunc.range f ∧ p y) ↔ ∃ x, p (↑f x)
Theorem: pathComponent_congr
File: Mathlib/Topology/PathConnected.lean

tactic: ext z
state_before: X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
⊢ pathComponent x = pathComponent y

tactic: constructor
state_before: case h
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
⊢ z ∈ pathComponent x ↔ z ∈ pathComponent y

tactic: intro h'
state_before: case h.mp
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
⊢ z ∈ pathComponent x → z ∈ pathComponent y

tactic: rw [pathComponent_symm]
state_before: case h.mp
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
h' : z ∈ pathComponent x
⊢ z ∈ pathComponent y

tactic: exact (h.trans h').symm
state_before: case h.mp
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
h' : z ∈ pathComponent x
⊢ y ∈ pathComponent z

tactic: intro h'
state_before: case h.mpr
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
⊢ z ∈ pathComponent y → z ∈ pathComponent x

tactic: rw [pathComponent_symm] at h'⊢
state_before: case h.mpr
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
h' : z ∈ pathComponent y
⊢ z ∈ pathComponent x

tactic: exact h'.trans h
state_before: case h.mpr
X : Type u_1
Y : Type ?u.624861
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z✝ : X
ι : Type ?u.624876
F : Set X
h : x ∈ pathComponent y
z : X
h' : y ∈ pathComponent z
⊢ x ∈ pathComponent z
Theorem: unitInterval.continuous_qRight
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: continuity
state_before: ⊢ Continuous fun p => 2 * ↑p.fst

tactic: continuity
state_before: ⊢ Continuous fun p => 1 + ↑p.snd
Theorem: List.foldr_map'
File: Mathlib/Data/List/Basic.lean

tactic: induction l generalizing a
state_before: ι : Type ?u.234464
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α β : Type u
g : α → β
f : α → α → α
f' : β → β → β
a : α
l : List α
h : ∀ (x y : α), f' (g x) (g y) = g (f x y)
⊢ foldr f' (g a) (map g l) = g (foldr f a l)

tactic: simp
state_before: case nil
ι : Type ?u.234464
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α β : Type u
g : α → β
f : α → α → α
f' : β → β → β
h : ∀ (x y : α), f' (g x) (g y) = g (f x y)
a : α
⊢ foldr f' (g a) (map g []) = g (foldr f a [])

tactic: simp [*, h]
state_before: case cons
ι : Type ?u.234464
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α β : Type u
g : α → β
f : α → α → α
f' : β → β → β
h : ∀ (x y : α), f' (g x) (g y) = g (f x y)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (a : α), foldr f' (g a) (map g tail✝) = g (foldr f a tail✝)
a : α
⊢ foldr f' (g a) (map g (head✝ :: tail✝)) = g (foldr f a (head✝ :: tail✝))
Theorem: CategoryTheory.Bicategory.id_whiskerLeft_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom
Theorem: Int.coe_greatestOfBdd_eq
File: Mathlib/Data/Int/LeastGreatest.lean

tactic: rcases greatestOfBdd b Hb Hinh with ⟨n, hn, h2n⟩
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
⊢ ↑(greatestOfBdd b Hb Hinh) = ↑(greatestOfBdd b' Hb' Hinh)

tactic: rcases greatestOfBdd b' Hb' Hinh with ⟨n', hn', h2n'⟩
state_before: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
⊢ ↑{ val := n, property := (_ : P n ∧ ∀ (z : ℤ), P z → z ≤ n) } = ↑(greatestOfBdd b' Hb' Hinh)

tactic: exact le_antisymm (h2n' _ hn) (h2n _ hn')
state_before: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → z ≤ b
Hb' : ∀ (z : ℤ), P z → z ≤ b'
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → z ≤ n
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → z ≤ n'
⊢ ↑{ val := n, property := (_ : P n ∧ ∀ (z : ℤ), P z → z ≤ n) } =
    ↑{ val := n', property := (_ : P n' ∧ ∀ (z : ℤ), P z → z ≤ n') }
Theorem: Nat.ArithmeticFunction.coe_coe
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext
state_before: R : Type u_1
inst✝ : AddGroupWithOne R
f : ArithmeticFunction ℕ
⊢ ↑↑f = ↑f

tactic: simp
state_before: case h
R : Type u_1
inst✝ : AddGroupWithOne R
f : ArithmeticFunction ℕ
x✝ : ℕ
⊢ ↑↑↑f x✝ = ↑↑f x✝
Theorem: Cardinal.add_eq_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [add_eq_max ha, max_eq_left hb]
state_before: a b : Cardinal
ha : ℵ₀ ≤ a
hb : b ≤ a
⊢ a + b = a
Theorem: Int.sign_eq_div_abs
File: Std/Data/Int/DivMod.lean

tactic: simp [az]
state_before: a : Int
az : a = 0
⊢ sign a = div a ↑(natAbs a)
Theorem: Polynomial.monic_toSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp_rw [Monic, leadingCoeff, natDegree_toSubring, ← coeff_toSubring p T hp]
state_before: R : Type u
S : Type ?u.93580
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ Monic (toSubring p T hp) ↔ Monic p

tactic: exact ⟨fun H => by rw [H, OneMemClass.coe_one], fun H => Subtype.coe_injective H⟩
state_before: R : Type u
S : Type ?u.93580
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ coeff (toSubring p T hp) (natDegree p) = 1 ↔ ↑(coeff (toSubring p T hp) (natDegree p)) = 1

tactic: rw [H, OneMemClass.coe_one]
state_before: R : Type u
S : Type ?u.93580
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
H : coeff (toSubring p T hp) (natDegree p) = 1
⊢ ↑(coeff (toSubring p T hp) (natDegree p)) = 1
Theorem: List.continuous_insertNth
File: Mathlib/Topology/List.lean

tactic: rw [ContinuousAt, nhds_prod_eq]
state_before: α : Type u_1
β : Type ?u.54167
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
x✝ : α × List α
a : α
l : List α
⊢ ContinuousAt (fun p => insertNth n p.fst p.snd) (a, l)

tactic: exact tendsto_insertNth'
state_before: α : Type u_1
β : Type ?u.54167
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
x✝ : α × List α
a : α
l : List α
⊢ Tendsto (fun p => insertNth n p.fst p.snd) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n (a, l).fst (a, l).snd))
Theorem: Hyperreal.infinitesimal_def
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simp [Infinitesimal, IsSt]
state_before: x : ℝ*
⊢ Infinitesimal x ↔ ∀ (r : ℝ), 0 < r → -↑r < x ∧ x < ↑r
Theorem: Path.Homotopy.transReflReparamAux_one
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: simp [transReflReparamAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transReflReparamAux 1 = 1

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ 1 ≤ 2⁻¹ → False
Theorem: SimpleGraph.card_commonNeighbors_le_degree_right
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp_rw [commonNeighbors_symm _ v w, card_commonNeighbors_le_degree_left]
state_before: ι : Sort ?u.298269
𝕜 : Type ?u.298272
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v w : V
⊢ Fintype.card ↑(commonNeighbors G v w) ≤ degree G w
Theorem: Int.natAbs_pos
File: Std/Data/Int/Lemmas.lean

tactic: rw [Nat.pos_iff_ne_zero, Ne, natAbs_eq_zero]
state_before: a : Int
⊢ 0 < natAbs a ↔ a ≠ 0
Theorem: MeasureTheory.FinStronglyMeasurable.mul
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine'
  ⟨fun n => hf.approx n * hg.approx n, _, fun x =>
    (hf.tendsto_approx x).mul (hg.tendsto_approx x)⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.243975
ι : Type ?u.243978
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ FinStronglyMeasurable (f * g) μ

tactic: intro n
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.243975
ι : Type ?u.243978
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ ∀ (n : ℕ), ↑↑μ (support ↑((fun n => FinStronglyMeasurable.approx hf n * FinStronglyMeasurable.approx hg n) n)) < ⊤

tactic: exact (measure_mono (support_mul_subset_left _ _)).trans_lt (hf.fin_support_approx n)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.243975
ι : Type ?u.243978
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : MonoidWithZero β
inst✝ : ContinuousMul β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ ↑↑μ (support ↑((fun n => FinStronglyMeasurable.approx hf n * FinStronglyMeasurable.approx hg n) n)) < ⊤
Theorem: Equiv.extendSubtype_not_mem
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: convert (e.toCompl ⟨x, hx⟩).2
state_before: α : Type u_1
β : Type ?u.159538
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ¬q (↑(extendSubtype e) x)

tactic: rw [e.extendSubtype_apply_of_not_mem _ hx]
state_before: case h.e'_1.h.e'_1
α : Type u_1
β : Type ?u.159538
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ↑(extendSubtype e) x = ↑(↑(toCompl e) { val := x, property := hx })
Theorem: Cardinal.nfpFamily_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [lift_id]
state_before: α : Type ?u.162257
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hι : (#ι) < c
hc' : c ≠ ℵ₀
a : Ordinal
hf : ∀ (i : ι) (b : Ordinal), b < ord c → f i b < ord c
⊢ lift (#ι) < c
Theorem: one_lt_mul_iff
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: simp only [one_lt_iff_ne_one, Ne.def, mul_eq_one_iff, not_and_or]
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
⊢ 1 < a * b ↔ 1 < a ∨ 1 < b
Theorem: LieModule.toEndomorphism_module_end
File: Mathlib/Algebra/Lie/OfAssociative.lean

tactic: ext (g m)
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ toEndomorphism R (Module.End R M) M = LieHom.id

tactic: simp [lie_eq_smul]
state_before: case h.h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
g : Module.End R M
m : M
⊢ ↑(↑(toEndomorphism R (Module.End R M) M) g) m = ↑(↑LieHom.id g) m
Theorem: Nat.bit_val
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: cases b
state_before: b : Bool
n : ℕ
⊢ bit b n = 2 * n + bif b then 1 else 0

tactic: apply bit0_val
state_before: case false
n : ℕ
⊢ bit false n = 2 * n + bif false then 1 else 0

case true
n : ℕ
⊢ bit true n = 2 * n + bif true then 1 else 0

tactic: apply bit1_val
state_before: case true
n : ℕ
⊢ bit true n = 2 * n + bif true then 1 else 0
Theorem: CategoryTheory.MonoidalCategory.tensorHom_inv_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, f.hom_inv_id, comp_tensor_id]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f.hom) ≫ (h ⊗ f.inv) = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
Theorem: Int.Prime.dvd_natAbs_of_coe_dvd_sq
File: Mathlib/Data/Int/NatPrime.lean

tactic: apply @Nat.Prime.dvd_of_dvd_pow _ _ 2 hp
state_before: p : ℕ
hp : Nat.Prime p
k : ℤ
h : ↑p ∣ k ^ 2
⊢ p ∣ natAbs k

tactic: rwa [sq, ← natAbs_mul, ← coe_nat_dvd_left, ← sq]
state_before: p : ℕ
hp : Nat.Prime p
k : ℤ
h : ↑p ∣ k ^ 2
⊢ p ∣ natAbs k ^ 2
Theorem: Finset.lcm_insert
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: by_cases h : b ∈ s
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.3612
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
⊢ lcm (insert b s) f = GCDMonoid.lcm (f b) (lcm s f)

tactic: apply fold_insert h
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.3612
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : ¬b ∈ s
⊢ lcm (insert b s) f = GCDMonoid.lcm (f b) (lcm s f)

tactic: rw [insert_eq_of_mem h,
  (lcm_eq_right_iff (f b) (s.lcm f) (Multiset.normalize_lcm (s.1.map f))).2 (dvd_lcm h)]
state_before: case pos
α : Type u_2
β : Type u_1
γ : Type ?u.3612
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∈ s
⊢ lcm (insert b s) f = GCDMonoid.lcm (f b) (lcm s f)
Theorem: PNat.XgcdType.v_eq_succ_vp
File: Mathlib/Data/PNat/Xgcd.lean

tactic: ext <;> dsimp [v, vp, w, z, a, b, succ₂] <;> (repeat' rw [Nat.succ_eq_add_one]; ring_nf)
state_before: u : XgcdType
⊢ v u = succ₂ (vp u)

tactic: repeat' rw [Nat.succ_eq_add_one]; ring_nf
state_before: case h₂
u : XgcdType
⊢ u.y * succ u.ap + succ u.zp * succ u.bp = succ (u.y + u.zp + u.bp + u.y * u.ap + u.zp * u.bp)

tactic: rw [Nat.succ_eq_add_one]
state_before: case h₂
u : XgcdType
⊢ 1 + u.y + u.y * u.ap + u.zp + u.zp * u.bp + u.bp = succ (u.y + u.y * u.ap + u.zp + u.zp * u.bp + u.bp)

tactic: ring_nf
state_before: case h₂
u : XgcdType
⊢ 1 + u.y + u.y * u.ap + u.zp + u.zp * u.bp + u.bp = u.y + u.y * u.ap + u.zp + u.zp * u.bp + u.bp + 1
Theorem: Set.univ_pi_singleton
File: Mathlib/Data/Set/Prod.lean

tactic: simp [funext_iff]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.136345
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f g : (i : ι) → α i
⊢ (g ∈ pi univ fun i => {f i}) ↔ g ∈ {f}