tasksource/leandojo huggingface dataset:
Theorem: Complex.arg_neg_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rcases lt_trichotomy x.im 0 with (hi | hi | hi)
state_before: x : ℂ
hx : x ≠ 0
⊢ ↑(arg (-x)) = ↑(arg x) + ↑π

tactic: rw [arg_neg_eq_arg_add_pi_of_im_neg hi, Real.Angle.coe_add]
state_before: case inl
x : ℂ
hx : x ≠ 0
hi : x.im < 0
⊢ ↑(arg (-x)) = ↑(arg x) + ↑π

tactic: rw [(ext rfl hi : x = x.re)]
state_before: case inr.inl
x : ℂ
hx : x ≠ 0
hi : x.im = 0
⊢ ↑(arg (-x)) = ↑(arg x) + ↑π

tactic: rcases lt_trichotomy x.re 0 with (hr | hr | hr)
state_before: case inr.inl
x : ℂ
hx : x ≠ 0
hi : x.im = 0
⊢ ↑(arg (-↑x.re)) = ↑(arg ↑x.re) + ↑π

tactic: rw [arg_ofReal_of_neg hr, ← ofReal_neg, arg_ofReal_of_nonneg (Left.neg_pos_iff.2 hr).le, ←
  Real.Angle.coe_add, ← two_mul, Real.Angle.coe_two_pi, Real.Angle.coe_zero]
state_before: case inr.inl.inl
x : ℂ
hx : x ≠ 0
hi : x.im = 0
hr : x.re < 0
⊢ ↑(arg (-↑x.re)) = ↑(arg ↑x.re) + ↑π

tactic: exact False.elim (hx (ext hr hi))
state_before: case inr.inl.inr.inl
x : ℂ
hx : x ≠ 0
hi : x.im = 0
hr : x.re = 0
⊢ ↑(arg (-↑x.re)) = ↑(arg ↑x.re) + ↑π

tactic: rw [arg_ofReal_of_nonneg hr.le, ← ofReal_neg, arg_ofReal_of_neg (Left.neg_neg_iff.2 hr),
  Real.Angle.coe_zero, zero_add]
state_before: case inr.inl.inr.inr
x : ℂ
hx : x ≠ 0
hi : x.im = 0
hr : 0 < x.re
⊢ ↑(arg (-↑x.re)) = ↑(arg ↑x.re) + ↑π

tactic: rw [arg_neg_eq_arg_sub_pi_of_im_pos hi, Real.Angle.coe_sub, Real.Angle.sub_coe_pi_eq_add_coe_pi]
state_before: case inr.inr
x : ℂ
hx : x ≠ 0
hi : 0 < x.im
⊢ ↑(arg (-x)) = ↑(arg x) + ↑π
Theorem: List.revzip_map_snd
File: Mathlib/Data/List/Zip.lean

tactic: rw [← unzip_right, unzip_revzip]
state_before: α : Type u
β : Type ?u.93614
γ : Type ?u.93617
δ : Type ?u.93620
ε : Type ?u.93623
l : List α
⊢ map Prod.snd (revzip l) = reverse l
Theorem: Finsupp.toFreeAbelianGroup_toFinsupp
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: rw [← AddMonoidHom.comp_apply, Finsupp.toFreeAbelianGroup_comp_toFinsupp, AddMonoidHom.id_apply]
state_before: X✝ : Type ?u.72357
X : Type u_1
x : FreeAbelianGroup X
⊢ ↑toFreeAbelianGroup (↑toFinsupp x) = x
Theorem: Set.equitableOn_iff_exists_image_subset_icc
File: Mathlib/Data/Set/Equitable.lean

tactic: simpa only [image_subset_iff] using equitableOn_iff_exists_le_le_add_one
state_before: α : Type u_1
β : Type ?u.4654
s : Set α
f : α → ℕ
⊢ EquitableOn s f ↔ ∃ b, f '' s ⊆ Icc b (b + 1)
Theorem: String.Iterator.ValidFor.atEnd
File: Std/Data/String/Lemmas.lean

tactic: simp [Iterator.atEnd, h.pos, h.toString]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ Iterator.atEnd it = true ↔ r = []

tactic: exact (Nat.add_le_add_iff_le_left _ _ 0).trans <| Nat.le_zero.trans utf8Len_eq_zero
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l ≥ utf8Len l + utf8Len r ↔ r = []
Theorem: Matrix.star_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type ?u.213834
m : Type u_1
n : Type ?u.213840
o : Type ?u.213843
m' : o → Type ?u.213848
n' : o → Type ?u.213853
R : Type ?u.213856
S : Type ?u.213859
α : Type v
β : Type w
γ : Type ?u.213866
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : NonUnitalSemiring α
inst✝ : StarRing α
v w : m → α
⊢ star v ⬝ᵥ w = star (star w ⬝ᵥ v)
Theorem: CategoryTheory.Limits.image_ι_comp_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: simp [h]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
inst✝² : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : HasImage f
inst✝ : Epi (factorThruImage f)
h : f ≫ g = 0
⊢ factorThruImage f ≫ image.ι f ≫ g = 0
Theorem: MeasureTheory.integral_neg
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.905489
𝕜 : Type ?u.905492
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
⊢ (∫ (a : α), -f a ∂μ) = -∫ (a : α), f a ∂μ

tactic: exact setToFun_neg (dominatedFinMeasAdditive_weightedSMul μ) f
state_before: α : Type u_2
E : Type u_1
F : Type ?u.905489
𝕜 : Type ?u.905492
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
⊢ (if hf : Integrable fun a => -f a then ↑L1.integralCLM (Integrable.toL1 (fun a => -f a) hf) else 0) =
    -if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0
Theorem: le_inv_iff_mul_le_one_right
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a * b ≤ b⁻¹ * b ↔ a * b ≤ 1
Theorem: String.utf8GetAux_add_right_cancel
File: Std/Data/String/Lemmas.lean

tactic: apply utf8InductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i =>
  utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p + n⟩ = utf8GetAux s i ⟨p⟩) <;>
simp [utf8GetAux]
state_before: s : List Char
i p n : Nat
⊢ utf8GetAux s { byteIdx := i + n } { byteIdx := p + n } = utf8GetAux s { byteIdx := i } { byteIdx := p }

tactic: intro c cs ⟨i⟩ h ih
state_before: case ind
s : List Char
i p n : Nat
⊢ ∀ (c : Char) (cs : List Char) (i : Pos),
    ¬i = { byteIdx := p } →
      utf8GetAux cs { byteIdx := i.byteIdx + csize c + n } { byteIdx := p + n } =
          utf8GetAux cs (i + c) { byteIdx := p } →
        (if { byteIdx := i.byteIdx + n } = { byteIdx := p + n } then c
          else utf8GetAux cs ({ byteIdx := i.byteIdx + n } + c) { byteIdx := p + n }) =
          if i = { byteIdx := p } then c else utf8GetAux cs (i + c) { byteIdx := p }

tactic: simp [Pos.ext_iff, Pos.addChar_eq] at h ⊢
state_before: case ind
s : List Char
i✝ p n : Nat
c : Char
cs : List Char
i : Nat
h : ¬{ byteIdx := i } = { byteIdx := p }
ih :
  utf8GetAux cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := p + n } =
    utf8GetAux cs ({ byteIdx := i } + c) { byteIdx := p }
⊢ (if { byteIdx := { byteIdx := i }.byteIdx + n } = { byteIdx := p + n } then c
    else utf8GetAux cs ({ byteIdx := { byteIdx := i }.byteIdx + n } + c) { byteIdx := p + n }) =
    if { byteIdx := i } = { byteIdx := p } then c else utf8GetAux cs ({ byteIdx := i } + c) { byteIdx := p }

tactic: simp [Nat.add_right_cancel_iff, h]
state_before: case ind
s : List Char
i✝ p n : Nat
c : Char
cs : List Char
i : Nat
ih :
  utf8GetAux cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := p + n } =
    utf8GetAux cs ({ byteIdx := i } + c) { byteIdx := p }
h : ¬i = p
⊢ (if i + n = p + n then c else utf8GetAux cs { byteIdx := i + n + csize c } { byteIdx := p + n }) =
    if i = p then c else utf8GetAux cs { byteIdx := i + csize c } { byteIdx := p }

tactic: rw [Nat.add_right_comm]
state_before: case ind
s : List Char
i✝ p n : Nat
c : Char
cs : List Char
i : Nat
ih :
  utf8GetAux cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := p + n } =
    utf8GetAux cs ({ byteIdx := i } + c) { byteIdx := p }
h : ¬i = p
⊢ utf8GetAux cs { byteIdx := i + n + csize c } { byteIdx := p + n } =
    utf8GetAux cs { byteIdx := i + csize c } { byteIdx := p }

tactic: exact ih
state_before: case ind
s : List Char
i✝ p n : Nat
c : Char
cs : List Char
i : Nat
ih :
  utf8GetAux cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := p + n } =
    utf8GetAux cs ({ byteIdx := i } + c) { byteIdx := p }
h : ¬i = p
⊢ utf8GetAux cs { byteIdx := i + csize c + n } { byteIdx := p + n } =
    utf8GetAux cs { byteIdx := i + csize c } { byteIdx := p }
Theorem: PEquiv.toMatrix_refl
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: ext
state_before: k : Type ?u.9804
l : Type ?u.9807
m : Type ?u.9810
n : Type u_1
α : Type v
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
⊢ toMatrix (PEquiv.refl n) = 1

tactic: simp [toMatrix_apply, one_apply]
state_before: case a.h
k : Type ?u.9804
l : Type ?u.9807
m : Type ?u.9810
n : Type u_1
α : Type v
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
i✝ x✝ : n
⊢ toMatrix (PEquiv.refl n) i✝ x✝ = OfNat.ofNat 1 i✝ x✝
Theorem: Matrix.toLin_kronecker
File: Mathlib/LinearAlgebra/TensorProduct/Matrix.lean

tactic: rw [← LinearEquiv.eq_symm_apply, toLin_symm, TensorProduct.toMatrix_map, toMatrix_toLin,
  toMatrix_toLin]
state_before: R : Type u_3
M : Type u_6
N : Type u_7
P : Type ?u.79666
M' : Type u_8
N' : Type u_9
ι : Type u_2
κ : Type u_5
τ : Type ?u.79681
ι' : Type u_1
κ' : Type u_4
inst✝¹⁸ : DecidableEq ι
inst✝¹⁷ : DecidableEq κ
inst✝¹⁶ : DecidableEq τ
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype κ
inst✝¹³ : Fintype τ
inst✝¹² : Fintype ι'
inst✝¹¹ : Fintype κ'
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R M'
inst✝ : Module R N'
bM : Basis ι R M
bN : Basis κ R N
bP : Basis τ R P
bM' : Basis ι' R M'
bN' : Basis κ' R N'
A : Matrix ι' ι R
B : Matrix κ' κ R
⊢ ↑(toLin (Basis.tensorProduct bM bN) (Basis.tensorProduct bM' bN')) (kroneckerMap (fun x x_1 => x * x_1) A B) =
    TensorProduct.map (↑(toLin bM bM') A) (↑(toLin bN bN') B)
Theorem: MeasureTheory.lintegral_sub'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: refine' ENNReal.eq_sub_of_add_eq hg_fin _
state_before: α : Type u_1
β : Type ?u.980208
γ : Type ?u.980211
δ : Type ?u.980214
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hg_fin : (∫⁻ (a : α), g a ∂μ) ≠ ⊤
h_le : g ≤ᵐ[μ] f
⊢ (∫⁻ (a : α), f a - g a ∂μ) = (∫⁻ (a : α), f a ∂μ) - ∫⁻ (a : α), g a ∂μ

tactic: rw [← lintegral_add_right' _ hg]
state_before: α : Type u_1
β : Type ?u.980208
γ : Type ?u.980211
δ : Type ?u.980214
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hg_fin : (∫⁻ (a : α), g a ∂μ) ≠ ⊤
h_le : g ≤ᵐ[μ] f
⊢ ((∫⁻ (a : α), f a - g a ∂μ) + ∫⁻ (a : α), g a ∂μ) = ∫⁻ (a : α), f a ∂μ

tactic: exact lintegral_congr_ae (h_le.mono fun x hx => tsub_add_cancel_of_le hx)
state_before: α : Type u_1
β : Type ?u.980208
γ : Type ?u.980211
δ : Type ?u.980214
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hg_fin : (∫⁻ (a : α), g a ∂μ) ≠ ⊤
h_le : g ≤ᵐ[μ] f
⊢ (∫⁻ (a : α), f a - g a + g a ∂μ) = ∫⁻ (a : α), f a ∂μ
Theorem: Real.smoothTransition.zero_iff_nonpos
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp only [smoothTransition, _root_.div_eq_zero_iff, (pos_denom x).ne', zero_iff_nonpos, or_false]
state_before: x : ℝ
⊢ smoothTransition x = 0 ↔ x ≤ 0
Theorem: MeasureTheory.Lp.simpleFunc.coeFn_le
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: rw [← Subtype.coe_le_coe, ← Lp.coeFn_le]
state_before: α : Type u_1
β : Type ?u.1924351
ι : Type ?u.1924354
E : Type ?u.1924357
F : Type ?u.1924360
𝕜 : Type ?u.1924363
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
G : Type u_2
inst✝ : NormedLatticeAddCommGroup G
f g : { x // x ∈ simpleFunc G p μ }
⊢ ↑↑↑f ≤ᵐ[μ] ↑↑↑g ↔ f ≤ g
Theorem: ContinuousLinearMap.adjoint_comp
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: ext v
state_before: 𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : F →L[𝕜] G
B : E →L[𝕜] F
⊢ ↑adjoint (comp A B) = comp (↑adjoint B) (↑adjoint A)

tactic: refine' ext_inner_left 𝕜 fun w => _
state_before: case h
𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : F →L[𝕜] G
B : E →L[𝕜] F
v : G
⊢ ↑(↑adjoint (comp A B)) v = ↑(comp (↑adjoint B) (↑adjoint A)) v

tactic: simp only [adjoint_inner_right, ContinuousLinearMap.coe_comp', Function.comp_apply]
state_before: case h
𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : F →L[𝕜] G
B : E →L[𝕜] F
v : G
w : (fun x => E) v
⊢ inner w (↑(↑adjoint (comp A B)) v) = inner w (↑(comp (↑adjoint B) (↑adjoint A)) v)
Theorem: Int.uniformEmbedding_coe_rat
File: Mathlib/Topology/Instances/Rat.lean

tactic: simpa using Int.pairwise_one_le_dist
state_before: ⊢ Pairwise fun x y => 1 ≤ dist ↑x ↑y
Theorem: Fin.le_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [tail]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α 0
q✝ : (i : Fin (n + 1)) → α i
p✝ : (i : Fin n) → α (succ i)
i : Fin n
y : α (succ i)
z : α 0
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
j : Fin n
⊢ q (succ j) ≤ cons x p (succ j) ↔ tail q j ≤ p j
Theorem: MeasureTheory.snorm_eq_zero_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases h_top : p = ∞
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2324170
G : Type ?u.2324173
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
⊢ snorm f p μ = 0 ↔ f =ᵐ[μ] 0

tactic: rw [snorm_eq_snorm' h0 h_top]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.2324170
G : Type ?u.2324173
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᵐ[μ] 0

tactic: exact snorm'_eq_zero_iff (ENNReal.toReal_pos h0 h_top) hf
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.2324170
G : Type ?u.2324173
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ snorm' f (ENNReal.toReal p) μ = 0 ↔ f =ᵐ[μ] 0

tactic: rw [h_top, snorm_exponent_top, snormEssSup_eq_zero_iff]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type ?u.2324170
G : Type ?u.2324173
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
h0 : p ≠ 0
h_top : p = ⊤
⊢ snorm f p μ = 0 ↔ f =ᵐ[μ] 0
Theorem: tendsto_Ioo_atBot
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← comap_coe_Ioo_nhdsWithin_Ioi, tendsto_comap_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto f l atBot ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Ioi a] a)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[Ioi a] a) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Ioi a] a)
Theorem: Nat.multinomial_univ_three
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: rw [multinomial, Fin.sum_univ_three, Fin.prod_univ_three]
state_before: α : Type ?u.20128
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ multinomial Finset.univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !)

tactic: rfl
state_before: α : Type ?u.20128
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ (Matrix.vecCons a ![b, c] 0 + Matrix.vecCons a ![b, c] 1 + Matrix.vecCons a ![b, c] 2)! /
      ((Matrix.vecCons a ![b, c] 0)! * (Matrix.vecCons a ![b, c] 1)! * (Matrix.vecCons a ![b, c] 2)!) =
    (a + b + c)! / (a ! * b ! * c !)
Theorem: List.support_sum_subset
File: Mathlib/Data/Finsupp/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
l : List (ι →₀ M)
⊢ (sum l).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ l

tactic: simp
state_before: case nil
ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
⊢ (sum []).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ []

tactic: simp only [List.sum_cons, Finset.union_comm]
state_before: case cons
ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
hd : ι →₀ M
tl : List (ι →₀ M)
IH : (sum tl).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ tl
⊢ (sum (hd :: tl)).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ (hd :: tl)

tactic: refine' Finsupp.support_add.trans (Finset.union_subset_union _ IH)
state_before: case cons
ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
hd : ι →₀ M
tl : List (ι →₀ M)
IH : (sum tl).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ tl
⊢ (hd + sum tl).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ (hd :: tl)

tactic: rfl
state_before: case cons
ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
hd : ι →₀ M
tl : List (ι →₀ M)
IH : (sum tl).support ⊆ foldr ((fun x x_1 => x ⊔ x_1) ∘ Finsupp.support) ∅ tl
⊢ hd.support ⊆ hd.support
Theorem: Traversable.pure_traverse
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: have : traverse pure x = pure (traverse (m := Id) pure x) :=
    (naturality (PureTransformation F) pure x).symm
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse pure x = pure x

tactic: rwa [id_traverse] at this
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
this : traverse pure x = pure (traverse pure x)
⊢ traverse pure x = pure x
Theorem: BoxIntegral.Prepartition.sum_split_boxes
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rw [split, sum_ofWithBot, Finset.sum_pair (I.splitLower_ne_splitUpper i x)]
state_before: ι : Type u_2
M✝ : Type ?u.34450
n : ℕ
I✝ J : Box ι
i✝ : ι
x✝ : ℝ
M : Type u_1
inst✝ : AddCommMonoid M
I : Box ι
i : ι
x : ℝ
f : Box ι → M
⊢ ∑ J in (split I i x).boxes, f J = Option.elim' 0 f (Box.splitLower I i x) + Option.elim' 0 f (Box.splitUpper I i x)
Theorem: Polynomial.gcd_content_eq_of_dvd_sub
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [content_eq_gcd_range_of_lt p (max p.natDegree q.natDegree).succ
    (lt_of_le_of_lt (le_max_left _ _) (Nat.lt_succ_self _))]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
h : ↑C a ∣ p - q
⊢ gcd a (content p) = gcd a (content q)

tactic: rw [content_eq_gcd_range_of_lt q (max p.natDegree q.natDegree).succ
    (lt_of_le_of_lt (le_max_right _ _) (Nat.lt_succ_self _))]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
h : ↑C a ∣ p - q
⊢ gcd a (Finset.gcd (Finset.range (Nat.succ (max (natDegree p) (natDegree q)))) (coeff p)) = gcd a (content q)

tactic: apply Finset.gcd_eq_of_dvd_sub
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
h : ↑C a ∣ p - q
⊢ gcd a (Finset.gcd (Finset.range (Nat.succ (max (natDegree p) (natDegree q)))) (coeff p)) =
    gcd a (Finset.gcd (Finset.range (Nat.succ (max (natDegree p) (natDegree q)))) (coeff q))

tactic: intro x _
state_before: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
h : ↑C a ∣ p - q
⊢ ∀ (x : ℕ), x ∈ Finset.range (Nat.succ (max (natDegree p) (natDegree q))) → a ∣ coeff p x - coeff q x

tactic: cases' h with w hw
state_before: case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
h : ↑C a ∣ p - q
x : ℕ
a✝ : x ∈ Finset.range (Nat.succ (max (natDegree p) (natDegree q)))
⊢ a ∣ coeff p x - coeff q x

tactic: use w.coeff x
state_before: case h.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
x : ℕ
a✝ : x ∈ Finset.range (Nat.succ (max (natDegree p) (natDegree q)))
w : (fun x => R[X]) a
hw : p - q = ↑C a * w
⊢ a ∣ coeff p x - coeff q x

tactic: rw [← coeff_sub, hw, coeff_C_mul]
state_before: case h.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
a : R
p q : R[X]
x : ℕ
a✝ : x ∈ Finset.range (Nat.succ (max (natDegree p) (natDegree q)))
w : (fun x => R[X]) a
hw : p - q = ↑C a * w
⊢ coeff p x - coeff q x = a * coeff w x
Theorem: Nat.cast_descFactorial_two
File: Mathlib/Data/Nat/Factorial/Cast.lean

tactic: rw [cast_descFactorial]
state_before: S : Type u_1
inst✝ : Ring S
a b : ℕ
⊢ ↑(descFactorial a 2) = ↑a * (↑a - 1)

tactic: cases a
state_before: S : Type u_1
inst✝ : Ring S
a b : ℕ
⊢ Polynomial.eval (↑(a - (2 - 1))) (pochhammer S 2) = ↑a * (↑a - 1)

tactic: simp
state_before: case zero
S : Type u_1
inst✝ : Ring S
b : ℕ
⊢ Polynomial.eval (↑(zero - (2 - 1))) (pochhammer S 2) = ↑zero * (↑zero - 1)

tactic: rw [succ_sub_succ, tsub_zero, cast_succ, add_sub_cancel, pochhammer_succ_right, pochhammer_one,
  Polynomial.X_mul, Polynomial.eval_mul_X, Polynomial.eval_add, Polynomial.eval_X, cast_one,
  Polynomial.eval_one]
state_before: case succ
S : Type u_1
inst✝ : Ring S
b n✝ : ℕ
⊢ Polynomial.eval (↑(succ n✝ - (2 - 1))) (pochhammer S 2) = ↑(succ n✝) * (↑(succ n✝) - 1)
Theorem: intervalIntegrable_iff
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [uIoc_eq_union, integrableOn_union, IntervalIntegrable]
state_before: ι : Type ?u.231038
𝕜 : Type ?u.231041
E : Type u_1
F : Type ?u.231047
A : Type ?u.231050
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
⊢ IntervalIntegrable f μ a b ↔ IntegrableOn f (Ι a b)