tasksource/leandojo huggingface dataset:
Theorem: Multiset.prod_dvd_prod_of_dvd
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: apply Multiset.induction_on' S
state_before: ι : Type ?u.85910
α : Type u_2
β : Type u_1
γ : Type ?u.85919
inst✝ : CommMonoid β
S : Multiset α
g1 g2 : α → β
h : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
⊢ prod (map g1 S) ∣ prod (map g2 S)

tactic: intro a T haS _ IH
state_before: case h₂
ι : Type ?u.85910
α : Type u_2
β : Type u_1
γ : Type ?u.85919
inst✝ : CommMonoid β
S : Multiset α
g1 g2 : α → β
h : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
⊢ ∀ {a : α} {s : Multiset α},
    a ∈ S → s ⊆ S → prod (map g1 s) ∣ prod (map g2 s) → prod (map g1 (insert a s)) ∣ prod (map g2 (insert a s))

tactic: simp [mul_dvd_mul (h a haS) IH]
state_before: case h₂
ι : Type ?u.85910
α : Type u_2
β : Type u_1
γ : Type ?u.85919
inst✝ : CommMonoid β
S : Multiset α
g1 g2 : α → β
h : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
a : α
T : Multiset α
haS : a ∈ S
a✝ : T ⊆ S
IH : prod (map g1 T) ∣ prod (map g2 T)
⊢ prod (map g1 (insert a T)) ∣ prod (map g2 (insert a T))

tactic: simp
state_before: case h₁
ι : Type ?u.85910
α : Type u_2
β : Type u_1
γ : Type ?u.85919
inst✝ : CommMonoid β
S : Multiset α
g1 g2 : α → β
h : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
⊢ prod (map g1 0) ∣ prod (map g2 0)
Theorem: Nat.Subtype.succ_le_of_lt
File: Mathlib/Logic/Denumerable.lean

tactic: rw [hk]
state_before: α : Type ?u.43600
β : Type ?u.43603
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
x y : ↑s
h : y < x
hx : ∃ m, ↑y + m + 1 ∈ s
k : ℕ
hk : ↑x = ↑y + k + 1
this : Nat.find hx ≤ k
⊢ ↑y + Nat.find hx + 1 ≤ ↑x

tactic: exact add_le_add_right (add_le_add_left this _) _
state_before: α : Type ?u.43600
β : Type ?u.43603
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
x y : ↑s
h : y < x
hx : ∃ m, ↑y + m + 1 ∈ s
k : ℕ
hk : ↑x = ↑y + k + 1
this : Nat.find hx ≤ k
⊢ ↑y + Nat.find hx + 1 ≤ ↑y + k + 1
Theorem: Int.mul_fmod_right
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, mul_fmod_left]
state_before: a b : Int
⊢ fmod (a * b) a = 0
Theorem: Nat.sqrt_le_add
File: Mathlib/Data/Nat/Sqrt.lean

tactic: rw [← succ_mul]
state_before: n : ℕ
⊢ n ≤ sqrt n * sqrt n + sqrt n + sqrt n

tactic: exact le_of_lt_succ (lt_succ_sqrt n)
state_before: n : ℕ
⊢ n ≤ succ (sqrt n) * sqrt n + sqrt n
Theorem: Vector.prod_set'
File: Mathlib/Data/Vector/Basic.lean

tactic: refine' (List.prod_set' v.toList i a).trans _
state_before: n : ℕ
α : Type u_1
β : Type ?u.63254
γ : Type ?u.63257
inst✝ : CommGroup α
v : Vector α n
i : Fin n
a : α
⊢ List.prod (toList (set v i a)) = List.prod (toList v) * (get v i)⁻¹ * a

tactic: simp [get_eq_get, mul_assoc]
state_before: n : ℕ
α : Type u_1
β : Type ?u.63254
γ : Type ?u.63257
inst✝ : CommGroup α
v : Vector α n
i : Fin n
a : α
⊢ (List.prod (toList v) * if hn : ↑i < List.length (toList v) then (List.nthLe (toList v) (↑i) hn)⁻¹ * a else 1) =
    List.prod (toList v) * (get v i)⁻¹ * a

tactic: rfl
state_before: n : ℕ
α : Type u_1
β : Type ?u.63254
γ : Type ?u.63257
inst✝ : CommGroup α
v : Vector α n
i : Fin n
a : α
⊢ List.nthLe (toList v) ↑i (_ : ↑i < List.length (toList v)) =
    List.get (toList v) (↑(Fin.cast (_ : n = List.length (toList v))) i)
Theorem: one_lt_div'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ 1 < a / b ↔ b < a
Theorem: NormedAddGroupHom.norm_comp_le_of_le'
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: rw [h]
state_before: V : Type ?u.470292
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g✝ : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
C₁ C₂ C₃ : ℝ
h : C₃ = C₂ * C₁
hg : ‖g‖ ≤ C₂
hf : ‖f‖ ≤ C₁
⊢ ‖NormedAddGroupHom.comp g f‖ ≤ C₃

tactic: exact norm_comp_le_of_le hg hf
state_before: V : Type ?u.470292
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g✝ : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
C₁ C₂ C₃ : ℝ
h : C₃ = C₂ * C₁
hg : ‖g‖ ≤ C₂
hf : ‖f‖ ≤ C₁
⊢ ‖NormedAddGroupHom.comp g f‖ ≤ C₂ * C₁
Theorem: Ordnode.Raised.add_left
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rcases H with (rfl | rfl)
state_before: α : Type ?u.244533
k n m : ℕ
H : Raised n m
⊢ Raised (k + n) (k + m)

tactic: exact Or.inl rfl
state_before: case inl
α : Type ?u.244533
k m : ℕ
⊢ Raised (k + m) (k + m)

tactic: exact Or.inr rfl
state_before: case inr
α : Type ?u.244533
k n : ℕ
⊢ Raised (k + n) (k + (n + 1))
Theorem: MulHom.srange_top_iff_surjective
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: rw [coe_srange, coe_top]
state_before: M : Type u_2
N✝ : Type ?u.61232
P : Type ?u.61235
σ : Type ?u.61238
inst✝³ : Mul M
inst✝² : Mul N✝
inst✝¹ : Mul P
S : Subsemigroup M
N : Type u_1
inst✝ : Mul N
f : M →ₙ* N
⊢ ↑(srange f) = ↑⊤ ↔ Set.range ↑f = Set.univ
Theorem: Real.Angle.toReal_injective
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: intro θ ψ h
state_before: ⊢ Function.Injective toReal

tactic: induction θ using Real.Angle.induction_on
state_before: θ ψ : Angle
h : toReal θ = toReal ψ
⊢ θ = ψ

tactic: induction ψ using Real.Angle.induction_on
state_before: case h
ψ : Angle
x✝ : ℝ
h : toReal ↑x✝ = toReal ψ
⊢ ↑x✝ = ψ

tactic: simpa [toReal_coe, toIocMod_eq_toIocMod, zsmul_eq_mul, mul_comm _ (2 * π), ←
  angle_eq_iff_two_pi_dvd_sub, eq_comm] using h
state_before: case h.h
x✝¹ x✝ : ℝ
h : toReal ↑x✝¹ = toReal ↑x✝
⊢ ↑x✝¹ = ↑x✝
Theorem: Std.AssocList.toList_toAssocList
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
l : AssocList α β
⊢ List.toAssocList (toList l) = l
Theorem: Polynomial.cyclotomic'_zero
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [cyclotomic', Finset.prod_empty, primitiveRoots_zero]
state_before: R✝ : Type ?u.32552
inst✝³ : CommRing R✝
inst✝² : IsDomain R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ cyclotomic' 0 R = 1
Theorem: Int.subNatNat_self
File: Std/Data/Int/Lemmas.lean

tactic: rw [subNatNat_of_sub_eq_zero (Nat.sub_self ..), Nat.sub_self, ofNat_zero]
state_before: m : Nat
⊢ subNatNat (succ m) (succ m) = 0
Theorem: Nat.ofDigits_digits_append_digits
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [ofDigits_append, ofDigits_digits, ofDigits_digits]
state_before: n✝ b m n : ℕ
⊢ ofDigits b (digits b n ++ digits b m) = n + b ^ List.length (digits b n) * m
Theorem: Matrix.mul_transvection_apply_same
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection, Matrix.mul_add, mul_comm]
state_before: n : Type u_1
p : Type ?u.14412
R : Type u₂
𝕜 : Type ?u.14417
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
a : n
c : R
M : Matrix n n R
⊢ (M ⬝ transvection i j c) a j = M a j + c * M a i
Theorem: Dfinsupp.equivFunOnFintype_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext x
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
⊢ ↑equivFunOnFintype (single i m) = Pi.single i m

tactic: dsimp [Pi.single, Function.update]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ ↑equivFunOnFintype (single i m) x = Pi.single i m x

tactic: simp [Dfinsupp.single_eq_pi_single, @eq_comm _ i]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x✝ : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
x : ι
⊢ ↑(single i m) x = if h : x = i then (_ : i = x) ▸ m else 0
Theorem: SymmetricRel.inter
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [SymmetricRel, preimage_inter, hU.eq, hV.eq]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.17571
U V : Set (α × α)
hU : SymmetricRel U
hV : SymmetricRel V
⊢ SymmetricRel (U ∩ V)
Theorem: MeasureTheory.Lp.ext
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: cases f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.358556
G : Type ?u.358559
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : { x // x ∈ Lp E p }
h : ↑↑f =ᵐ[μ] ↑↑g
⊢ f = g

tactic: cases g
state_before: case mk
α : Type u_1
E : Type u_2
F : Type ?u.358556
G : Type ?u.358559
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : { x // x ∈ Lp E p }
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p
h : ↑↑{ val := val✝, property := property✝ } =ᵐ[μ] ↑↑g
⊢ { val := val✝, property := property✝ } = g

tactic: simp only [Subtype.mk_eq_mk]
state_before: case mk.mk
α : Type u_1
E : Type u_2
F : Type ?u.358556
G : Type ?u.358559
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p
h : ↑↑{ val := val✝¹, property := property✝¹ } =ᵐ[μ] ↑↑{ val := val✝, property := property✝ }
⊢ { val := val✝¹, property := property✝¹ } = { val := val✝, property := property✝ }

tactic: exact AEEqFun.ext h
state_before: case mk.mk
α : Type u_1
E : Type u_2
F : Type ?u.358556
G : Type ?u.358559
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p
h : ↑↑{ val := val✝¹, property := property✝¹ } =ᵐ[μ] ↑↑{ val := val✝, property := property✝ }
⊢ val✝¹ = val✝
Theorem: expSeries_eq_expSeries
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [expSeries_apply_eq, expSeries_apply_eq, inv_nat_cast_smul_eq 𝕂 𝕂']
state_before: 𝕂 : Type u_2
𝕂' : Type u_3
𝔸 : Type u_1
inst✝⁶ : Field 𝕂
inst✝⁵ : Field 𝕂'
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : Algebra 𝕂' 𝔸
inst✝¹ : TopologicalSpace 𝔸
inst✝ : TopologicalRing 𝔸
n : ℕ
x : 𝔸
⊢ (↑(expSeries 𝕂 𝔸 n) fun x_1 => x) = ↑(expSeries 𝕂' 𝔸 n) fun x_1 => x
Theorem: MvPolynomial.mem_restrictTotalDegree
File: Mathlib/RingTheory/MvPolynomial/Basic.lean

tactic: rw [totalDegree, Finset.sup_le_iff]
state_before: σ : Type u
R : Type v
inst✝ : CommRing R
p✝ m : ℕ
p : MvPolynomial σ R
⊢ p ∈ restrictTotalDegree σ R m ↔ totalDegree p ≤ m

tactic: rfl
state_before: σ : Type u
R : Type v
inst✝ : CommRing R
p✝ m : ℕ
p : MvPolynomial σ R
⊢ p ∈ restrictTotalDegree σ R m ↔ ∀ (b : σ →₀ ℕ), b ∈ support p → (Finsupp.sum b fun x e => e) ≤ m
Theorem: PNat.mod_add_div'
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [mul_comm]
state_before: m k : ℕ+
⊢ ↑(mod m k) + div m k * ↑k = ↑m

tactic: exact mod_add_div _ _
state_before: m k : ℕ+
⊢ ↑(mod m k) + ↑k * div m k = ↑m
Theorem: Complex.abs_exp_mul_exp_add_exp_neg_le_of_abs_im_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp only [abs_exp, Real.exp_le_exp, ofReal_mul_re, add_re, exp_re, neg_im, Real.cos_neg, ←
  add_mul, mul_assoc, mul_comm (Real.cos b), neg_re, ← Real.cos_abs z.im]
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
⊢ ↑abs (exp (↑a * (exp z + exp (-z)))) ≤ Real.exp (a * Real.cos b * Real.exp (Abs.abs z.re))

tactic: have : Real.exp (|z.re|) ≤ Real.exp z.re + Real.exp (-z.re) :=
  apply_abs_le_add_of_nonneg (fun x => (Real.exp_pos x).le) z.re
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
⊢ a * ((Real.exp z.re + Real.exp (-z.re)) * Real.cos (Abs.abs z.im)) ≤ a * (Real.exp (Abs.abs z.re) * Real.cos b)

tactic: refine' mul_le_mul_of_nonpos_left (mul_le_mul this _ _ ((Real.exp_pos _).le.trans this)) ha
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
this : Real.exp (Abs.abs z.re) ≤ Real.exp z.re + Real.exp (-z.re)
⊢ a * ((Real.exp z.re + Real.exp (-z.re)) * Real.cos (Abs.abs z.im)) ≤ a * (Real.exp (Abs.abs z.re) * Real.cos b)

tactic: exact
  Real.cos_le_cos_of_nonneg_of_le_pi (_root_.abs_nonneg _)
    (hb.trans <| half_le_self <| Real.pi_pos.le) hz
state_before: case refine'_1
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
this : Real.exp (Abs.abs z.re) ≤ Real.exp z.re + Real.exp (-z.re)
⊢ Real.cos b ≤ Real.cos (Abs.abs z.im)

tactic: refine' Real.cos_nonneg_of_mem_Icc ⟨_, hb⟩
state_before: case refine'_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
this : Real.exp (Abs.abs z.re) ≤ Real.exp z.re + Real.exp (-z.re)
⊢ 0 ≤ Real.cos b

tactic: exact (neg_nonpos.2 <| Real.pi_div_two_pos.le).trans ((_root_.abs_nonneg _).trans hz)
state_before: case refine'_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : Abs.abs z.im ≤ b
hb : b ≤ π / 2
this : Real.exp (Abs.abs z.re) ≤ Real.exp z.re + Real.exp (-z.re)
⊢ -(π / 2) ≤ b
Theorem: Subalgebra.fg_of_submodule_fg
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [Algebra.top_toSubmodule, eq_top_iff, ← hs, span_le]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
h : Submodule.FG ⊤
s : Finset A
hs : span R ↑s = ⊤
⊢ ↑toSubmodule (Algebra.adjoin R ↑s) = ↑toSubmodule ⊤

tactic: exact Algebra.subset_adjoin
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
h : Submodule.FG ⊤
s : Finset A
hs : span R ↑s = ⊤
⊢ ↑s ⊆ ↑(↑toSubmodule (Algebra.adjoin R ↑s))
Theorem: SubfieldClass.coe_rat_mem
File: Mathlib/FieldTheory/Subfield.lean

tactic: simpa only [Rat.cast_def] using div_mem (coe_int_mem s x.num) (coe_nat_mem s x.den)
state_before: K : Type u
L : Type v
M : Type w
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Field M
S : Type u_1
inst✝ : SetLike S K
h : SubfieldClass S K
s : S
x : ℚ
⊢ ↑x ∈ s
Theorem: Real.tan_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [tan_eq_sin_div_cos, cos_arcsin]
state_before: x : ℝ
⊢ tan (arcsin x) = x / sqrt (1 - x ^ 2)

tactic: by_cases hx₁ : -1 ≤ x
state_before: x : ℝ
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: by_cases hx₂ : x ≤ 1
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: rw [sin_arcsin hx₁ hx₂]
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: have h : sqrt (1 - x ^ 2) = 0 := sqrt_eq_zero_of_nonpos (by nlinarith)
state_before: case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: rw [h]
state_before: case neg
x : ℝ
hx₁ : ¬-1 ≤ x
h : sqrt (1 - x ^ 2) = 0
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: simp
state_before: case neg
x : ℝ
hx₁ : ¬-1 ≤ x
h : sqrt (1 - x ^ 2) = 0
⊢ sin (arcsin x) / 0 = x / 0

tactic: nlinarith
state_before: x : ℝ
hx₁ : ¬-1 ≤ x
⊢ 1 - x ^ 2 ≤ 0

tactic: have h : sqrt (1 - x ^ 2) = 0 := sqrt_eq_zero_of_nonpos (by nlinarith)
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: rw [h]
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
h : sqrt (1 - x ^ 2) = 0
⊢ sin (arcsin x) / sqrt (1 - x ^ 2) = x / sqrt (1 - x ^ 2)

tactic: simp
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
h : sqrt (1 - x ^ 2) = 0
⊢ sin (arcsin x) / 0 = x / 0

tactic: nlinarith
state_before: x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ 1 - x ^ 2 ≤ 0
Theorem: Filter.eventually_atTop_prod_self'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [eventually_atTop_prod_self, ball_cond_comm]
state_before: ι : Type ?u.302627
ι' : Type ?u.302630
α : Type u_1
β : Type ?u.302636
γ : Type ?u.302639
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
p : α × α → Prop
⊢ (∀ᶠ (x : α × α) in atTop, p x) ↔ ∃ a, ∀ (k : α), k ≥ a → ∀ (l : α), l ≥ a → p (k, l)
Theorem: MeasureTheory.VectorMeasure.neg_le_neg
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro j hj₁
state_before: α : Type u_1
β : Type ?u.548949
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : restrict v i ≤ restrict w i
⊢ restrict (-w) i ≤ restrict (-v) i

tactic: rw [restrict_apply _ hi hj₁, restrict_apply _ hi hj₁, neg_apply, neg_apply]
state_before: α : Type u_1
β : Type ?u.548949
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : restrict v i ≤ restrict w i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑(restrict (-w) i) j ≤ ↑(restrict (-v) i) j

tactic: refine' neg_le_neg _
state_before: α : Type u_1
β : Type ?u.548949
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : restrict v i ≤ restrict w i
j : Set α
hj₁ : MeasurableSet j
⊢ -↑w (j ∩ i) ≤ -↑v (j ∩ i)

tactic: rw [← restrict_apply _ hi hj₁, ← restrict_apply _ hi hj₁]
state_before: α : Type u_1
β : Type ?u.548949
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : restrict v i ≤ restrict w i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑v (j ∩ i) ≤ ↑w (j ∩ i)

tactic: exact h j hj₁
state_before: α : Type u_1
β : Type ?u.548949
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : restrict v i ≤ restrict w i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑(restrict v i) j ≤ ↑(restrict w i) j
Theorem: Nat.eq_sqrt'
File: Mathlib/Data/Nat/Sqrt.lean

tactic: simpa only [pow_two] using eq_sqrt
state_before: n q : ℕ
⊢ q = sqrt n ↔ q ^ 2 ≤ n ∧ n < (q + 1) ^ 2
Theorem: Matrix.fromBlocks_add
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_3
m : Type u_4
n : Type u_2
o : Type u_5
p : Type ?u.36919
q : Type ?u.36922
m' : o → Type ?u.36927
n' : o → Type ?u.36932
p' : o → Type ?u.36937
R : Type ?u.36940
S : Type ?u.36943
α : Type u_1
β : Type ?u.36949
inst✝ : Add α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix n l α
B' : Matrix n m α
C' : Matrix o l α
D' : Matrix o m α
⊢ fromBlocks A B C D + fromBlocks A' B' C' D' = fromBlocks (A + A') (B + B') (C + C') (D + D')

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> rfl
state_before: case a.h
l : Type u_3
m : Type u_4
n : Type u_2
o : Type u_5
p : Type ?u.36919
q : Type ?u.36922
m' : o → Type ?u.36927
n' : o → Type ?u.36932
p' : o → Type ?u.36937
R : Type ?u.36940
S : Type ?u.36943
α : Type u_1
β : Type ?u.36949
inst✝ : Add α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix n l α
B' : Matrix n m α
C' : Matrix o l α
D' : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (fromBlocks A B C D + fromBlocks A' B' C' D') i j = fromBlocks (A + A') (B + B') (C + C') (D + D') i j
Theorem: SimpleGraph.Walk.takeUntil_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w v' w' : V
p : Walk G v w
hv : v = v'
hw : w = w'
h : u ∈ support (Walk.copy p hv hw)
⊢ u ∈ support p

tactic: exact h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v' w' : V
p : Walk G v' w'
h : u ∈ support (Walk.copy p (_ : v' = v') (_ : w' = w'))
⊢ u ∈ support p

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w v' w' : V
p : Walk G v w
hv : v = v'
hw : w = w'
h : u ∈ support (Walk.copy p hv hw)
⊢ takeUntil (Walk.copy p hv hw) u h = Walk.copy (takeUntil p u (_ : u ∈ support p)) hv (_ : u = u)

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v' w' : V
p : Walk G v' w'
h : u ∈ support (Walk.copy p (_ : v' = v') (_ : w' = w'))
⊢ takeUntil (Walk.copy p (_ : v' = v') (_ : w' = w')) u h =
    Walk.copy (takeUntil p u (_ : u ∈ support p)) (_ : v' = v') (_ : u = u)
Theorem: inseparable_iff_mem_closure
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [specializes_iff_mem_closure, and_comm]
state_before: X : Type u_1
Y : Type ?u.31356
Z : Type ?u.31359
α : Type ?u.31362
ι : Type ?u.31365
π : ι → Type ?u.31370
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
⊢ x ⤳ y ∧ y ⤳ x ↔ x ∈ closure {y} ∧ y ∈ closure {x}
Theorem: Finset.prod_range_succ_comm
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [range_succ, prod_insert not_mem_range_self]
state_before: ι : Type ?u.431878
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x in range (n + 1), f x = f n * ∏ x in range n, f x
Theorem: pow_succ_padicValNat_not_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat_dvd_iff_le hn, not_le]
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ ¬p ^ (padicValNat p n + 1) ∣ n

tactic: exact Nat.lt_succ_self _
state_before: p n : ℕ
hp : Fact (Nat.Prime p)
hn : n ≠ 0
⊢ padicValNat p n < padicValNat p n + 1
Theorem: List.sizeOf_kerase
File: Mathlib/Data/List/Sigma.lean

tactic: simp only [SizeOf.sizeOf, _sizeOf_1]
state_before: α✝ : Type u
β✝ : α✝ → Type v
l l₁ l₂ : List (Sigma β✝)
inst✝² : DecidableEq α✝
α : Type u_1
β : α → Type u_2
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
xs : List (Sigma β)
⊢ sizeOf (kerase x xs) ≤ sizeOf xs

tactic: induction' xs with y ys
state_before: α✝ : Type u
β✝ : α✝ → Type v
l l₁ l₂ : List (Sigma β✝)
inst✝² : DecidableEq α✝
α : Type u_1
β : α → Type u_2
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
xs : List (Sigma β)
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x xs) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) xs

tactic: simp
state_before: case nil
α✝ : Type u
β✝ : α✝ → Type v
l l₁ l₂ : List (Sigma β✝)
inst✝² : DecidableEq α✝
α : Type u_1
β : α → Type u_2
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x []) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) []

tactic: by_cases x = y.1 <;> simp [*]
state_before: case cons
α✝ : Type u
β✝ : α✝ → Type v
l l₁ l₂ : List (Sigma β✝)
inst✝² : DecidableEq α✝
α : Type u_1
β : α → Type u_2
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
y : Sigma β
ys : List (Sigma β)
tail_ih✝ :
  rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x ys) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) ys
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x (y :: ys)) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (y :: ys)