tasksource/leandojo huggingface dataset:
Theorem: EulerSine.integral_cos_mul_cos_pow_even
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

tactic: convert integral_cos_mul_cos_pow (by linarith : 2 ≤ 2 * n + 2) hz using 3
state_before: z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ ((1 - z ^ 2 / (↑n + 1) ^ 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (2 * n + 2)) =
    (2 * ↑n + 1) / (2 * ↑n + 2) * ∫ (x : ℝ) in 0 ..π / 2, Complex.cos (2 * z * ↑x) * ↑(cos x) ^ (2 * n)

tactic: linarith
state_before: z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ 2 ≤ 2 * n + 2

tactic: simp only [Nat.cast_add, Nat.cast_mul, Nat.cast_two]
state_before: case h.e'_2.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ z ^ 2 / (↑n + 1) ^ 2 = 4 * z ^ 2 / ↑(2 * n + 2) ^ 2

tactic: nth_rw 2 [← mul_one (2 : ℂ)]
state_before: case h.e'_2.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ z ^ 2 / (↑n + 1) ^ 2 = 4 * z ^ 2 / (2 * ↑n + 2) ^ 2

tactic: rw [← mul_add, mul_pow, ← div_div]
state_before: case h.e'_2.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ z ^ 2 / (↑n + 1) ^ 2 = 4 * z ^ 2 / (2 * ↑n + 2 * 1) ^ 2

tactic: ring
state_before: case h.e'_2.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ z ^ 2 / (↑n + 1) ^ 2 = 4 * z ^ 2 / 2 ^ 2 / (↑n + 1) ^ 2

tactic: push_cast
state_before: case h.e'_3.h.e'_5.h.e'_5
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ 2 * ↑n + 1 = ↑(2 * n + 2) - 1

tactic: ring
state_before: case h.e'_3.h.e'_5.h.e'_5
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ 2 * ↑n + 1 = 2 * ↑n + 2 - 1

tactic: push_cast
state_before: case h.e'_3.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ 2 * ↑n + 2 = ↑(2 * n + 2)

tactic: ring
state_before: case h.e'_3.h.e'_5.h.e'_6
z : ℂ
n✝ n : ℕ
hz : z ≠ 0
⊢ 2 * ↑n + 2 = 2 * ↑n + 2
Theorem: hasSum_extend_zero
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [← hg.hasSum_iff, extend_comp hg]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.24186
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : β → γ
hg : Injective g
⊢ HasSum (extend g f 0) a ↔ HasSum f a

tactic: exact extend_apply' _ _
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.24186
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : β → γ
hg : Injective g
⊢ ∀ (x : γ), ¬x ∈ Set.range g → extend g f 0 x = 0
Theorem: div_nonpos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [division_def, mul_nonpos_iff]
state_before: ι : Type ?u.139274
α : Type u_1
β : Type ?u.139280
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
Theorem: Function.piCongrLeft'_symm_update
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [(e.piCongrLeft' P).symm_apply_eq, piCongrLeft'_update]
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (b : β) → P (↑e.symm b)
b : β
x : P (↑e.symm b)
⊢ ↑(Equiv.piCongrLeft' P e).symm (update f b x) = update (↑(Equiv.piCongrLeft' P e).symm f) (↑e.symm b) x
Theorem: Set.iUnion_pi_of_monotone
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [pi_def, biInter_eq_iInter, preimage_iUnion]
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : Set.Finite I
hs : ∀ (i : ι), i ∈ I → Monotone (s i)
⊢ (⋃ (j : ι'), pi I fun i => s i j) = pi I fun i => ⋃ (j : ι'), s i j

tactic: haveI := hI.fintype.finite
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : Set.Finite I
hs : ∀ (i : ι), i ∈ I → Monotone (s i)
⊢ (⋃ (j : ι'), ⋂ (x : ↑I), eval ↑x ⁻¹' s (↑x) j) = ⋂ (x : ↑I), ⋃ (i : ι'), eval ↑x ⁻¹' s (↑x) i

tactic: refine' iUnion_iInter_of_monotone (ι' := ι') (fun (i : I) j₁ j₂ h => _)
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : Set.Finite I
hs : ∀ (i : ι), i ∈ I → Monotone (s i)
this : Finite ↑I
⊢ (⋃ (j : ι'), ⋂ (x : ↑I), eval ↑x ⁻¹' s (↑x) j) = ⋂ (x : ↑I), ⋃ (i : ι'), eval ↑x ⁻¹' s (↑x) i

tactic: exact preimage_mono <| hs i i.2 h
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
inst✝¹ : LinearOrder ι'
inst✝ : Nonempty ι'
α : ι → Type u_3
I : Set ι
s : (i : ι) → ι' → Set (α i)
hI : Set.Finite I
hs : ∀ (i : ι), i ∈ I → Monotone (s i)
this : Finite ↑I
i : ↑I
j₁ j₂ : ι'
h : j₁ ≤ j₂
⊢ eval ↑i ⁻¹' s (↑i) j₁ ≤ eval ↑i ⁻¹' s (↑i) j₂
Theorem: MeasureTheory.OuterMeasure.biUnion_null_iff
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: haveI := hs.toEncodable
state_before: α : Type u_1
β : Type u_2
R : Type ?u.7093
R' : Type ?u.7096
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s : Set β
hs : Set.Countable s
t : β → Set α
⊢ ↑m (⋃ (i : β) (_ : i ∈ s), t i) = 0 ↔ ∀ (i : β), i ∈ s → ↑m (t i) = 0

tactic: rw [biUnion_eq_iUnion, iUnion_null_iff, SetCoe.forall']
state_before: α : Type u_1
β : Type u_2
R : Type ?u.7093
R' : Type ?u.7096
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s : Set β
hs : Set.Countable s
t : β → Set α
this : Encodable ↑s
⊢ ↑m (⋃ (i : β) (_ : i ∈ s), t i) = 0 ↔ ∀ (i : β), i ∈ s → ↑m (t i) = 0
Theorem: BilinForm.IsAlt.isRefl
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: intro x y h
state_before: R : Type ?u.965534
M : Type ?u.965537
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type ?u.966185
M₂ : Type ?u.966188
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.966375
M₃ : Type ?u.966378
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.966966
K : Type ?u.966969
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.968183
M₂'' : Type ?u.968186
inst✝³ : AddCommMonoid M₂'
inst✝² : AddCommMonoid M₂''
inst✝¹ : Module R₂ M₂'
inst✝ : Module R₂ M₂''
H : IsAlt B₁
⊢ IsRefl B₁

tactic: rw [← neg_eq H, h, neg_zero]
state_before: R : Type ?u.965534
M : Type ?u.965537
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type ?u.966185
M₂ : Type ?u.966188
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.966375
M₃ : Type ?u.966378
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.966966
K : Type ?u.966969
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.968183
M₂'' : Type ?u.968186
inst✝³ : AddCommMonoid M₂'
inst✝² : AddCommMonoid M₂''
inst✝¹ : Module R₂ M₂'
inst✝ : Module R₂ M₂''
H : IsAlt B₁
x y : M₁
h : bilin B₁ x y = 0
⊢ bilin B₁ y x = 0
Theorem: Real.Angle.pi_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_injective.ne_iff, toReal_pi, toReal_zero]
state_before: ⊢ ↑π ≠ 0

tactic: exact Real.pi_ne_zero
state_before: ⊢ π ≠ 0
Theorem: IsCoercive.ker_eq_bot
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

tactic: rw [LinearMapClass.ker_eq_bot]
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ ker (continuousLinearMapOfBilin B) = ⊥

tactic: rcases coercive.antilipschitz with ⟨_, _, antilipschitz⟩
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ Function.Injective ↑(continuousLinearMapOfBilin B)

tactic: exact antilipschitz.injective
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
w✝ : ℝ≥0
left✝ : 0 < w✝
antilipschitz : AntilipschitzWith w✝ ↑(continuousLinearMapOfBilin B)
⊢ Function.Injective ↑(continuousLinearMapOfBilin B)
Theorem: OnePoint.tendsto_nhds_infty'
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp [nhds_infty_eq, and_comm]
state_before: X : Type u_2
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
α : Type u_1
f : OnePoint X → α
l : Filter α
⊢ Tendsto f (𝓝 ∞) l ↔ Tendsto f (pure ∞) l ∧ Tendsto (f ∘ some) (coclosedCompact X) l
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand'
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: apply Obj.map_on_summand
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ Splitting.ιSummand (splitting K) A ≫ (obj K).map θ =
    Termwise.mapMono K (image.ι (θ.unop ≫ Splitting.IndexSet.e A)) ≫
      Splitting.ιSummand (splitting K) (Splitting.IndexSet.pull A θ)

tactic: apply image.fac
state_before: case fac
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ factorThruImage (θ.unop ≫ Splitting.IndexSet.e A) ≫ image.ι (θ.unop ≫ Splitting.IndexSet.e A) =
    θ.unop ≫ Splitting.IndexSet.e A
Theorem: Decidable.imp_or
File: Std/Logic.lean

tactic: by_cases a <;> simp_all
state_before: a b c : Prop
inst✝ : Decidable a
⊢ a → b ∨ c ↔ (a → b) ∨ (a → c)
Theorem: Ideal.polynomial_not_isField
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: nontriviality R
state_before: R : Type u
S : Type ?u.190529
inst✝ : Ring R
⊢ ¬IsField R[X]

tactic: intro hR
state_before: R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
⊢ ¬IsField R[X]

tactic: obtain ⟨p, hp⟩ := hR.mul_inv_cancel X_ne_zero
state_before: R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
hR : IsField R[X]
⊢ False

tactic: have hp0 : p ≠ 0 := right_ne_zero_of_mul_eq_one hp
state_before: case intro
R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
hR : IsField R[X]
p : R[X]
hp : X * p = 1
⊢ False

tactic: have := degree_lt_degree_mul_X hp0
state_before: case intro
R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
hR : IsField R[X]
p : R[X]
hp : X * p = 1
hp0 : p ≠ 0
⊢ False

tactic: rw [← X_mul, congr_arg degree hp, degree_one, Nat.WithBot.lt_zero_iff, degree_eq_bot] at this
state_before: case intro
R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
hR : IsField R[X]
p : R[X]
hp : X * p = 1
hp0 : p ≠ 0
this : degree p < degree (p * X)
⊢ False

tactic: exact hp0 this
state_before: case intro
R : Type u
S : Type ?u.190529
inst✝ : Ring R
✝ : Nontrivial R
hR : IsField R[X]
p : R[X]
hp : X * p = 1
hp0 : p ≠ 0
this : p = 0
⊢ False
Theorem: fib_isSol_fibRec
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec]
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ LinearRecurrence.IsSolution fibRec fun x => ↑(Nat.fib x)

tactic: intro n
state_before: α : Type u_1
inst✝ : CommSemiring α
⊢ LinearRecurrence.IsSolution { order := 2, coeffs := ![1, 1] } fun x => ↑(Nat.fib x)

tactic: simp only
state_before: α : Type u_1
inst✝ : CommSemiring α
n : ℕ
⊢ (fun x => ↑(Nat.fib x)) (n + { order := 2, coeffs := ![1, 1] }.order) =
    Finset.sum Finset.univ fun i =>
      LinearRecurrence.coeffs { order := 2, coeffs := ![1, 1] } i * (fun x => ↑(Nat.fib x)) (n + ↑i)

tactic: rw [Nat.fib_add_two, add_comm]
state_before: α : Type u_1
inst✝ : CommSemiring α
n : ℕ
⊢ ↑(Nat.fib (n + 2)) = Finset.sum Finset.univ fun x => Matrix.vecCons 1 ![1] x * ↑(Nat.fib (n + ↑x))

tactic: simp [Finset.sum_fin_eq_sum_range, Finset.sum_range_succ']
state_before: α : Type u_1
inst✝ : CommSemiring α
n : ℕ
⊢ ↑(Nat.fib (n + 1) + Nat.fib n) = Finset.sum Finset.univ fun x => Matrix.vecCons 1 ![1] x * ↑(Nat.fib (n + ↑x))
Theorem: MvPolynomial.homogeneousComponent_zero
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: ext1 d
state_before: σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ ↑(homogeneousComponent 0) φ = ↑C (coeff 0 φ)

tactic: rcases em (d = 0) with (rfl | hd)
state_before: case a
σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d (↑(homogeneousComponent 0) φ) = coeff d (↑C (coeff 0 φ))

tactic: simp only [coeff_homogeneousComponent, sum_eq_zero_iff, Finsupp.zero_apply, if_true, coeff_C,
  eq_self_iff_true, forall_true_iff]
state_before: case a.inl
σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ coeff 0 (↑(homogeneousComponent 0) φ) = coeff 0 (↑C (coeff 0 φ))

tactic: rw [coeff_homogeneousComponent, if_neg, coeff_C, if_neg (Ne.symm hd)]
state_before: case a.inr
σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : ¬d = 0
⊢ coeff d (↑(homogeneousComponent 0) φ) = coeff d (↑C (coeff 0 φ))

tactic: simp only [FunLike.ext_iff, Finsupp.zero_apply] at hd
state_before: case a.inr.hnc
σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : ¬d = 0
⊢ ¬∑ i in d.support, ↑d i = 0

tactic: simp [hd]
state_before: case a.inr.hnc
σ : Type u_1
τ : Type ?u.182889
R : Type u_2
S : Type ?u.182895
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
hd : ¬∀ (x : σ), ↑d x = 0
⊢ ¬∑ i in d.support, ↑d i = 0
Theorem: Nat.add_mod_eq_ite
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: cases k
state_before: m n k l : ℕ
⊢ (m + n) % k = if k ≤ m % k + n % k then m % k + n % k - k else m % k + n % k

tactic: simp [mod_zero]
state_before: case zero
m n l : ℕ
⊢ (m + n) % zero = if zero ≤ m % zero + n % zero then m % zero + n % zero - zero else m % zero + n % zero

case succ
m n l n✝ : ℕ
⊢ (m + n) % succ n✝ =
    if succ n✝ ≤ m % succ n✝ + n % succ n✝ then m % succ n✝ + n % succ n✝ - succ n✝ else m % succ n✝ + n % succ n✝

tactic: rw [Nat.add_mod]
state_before: case succ
m n l n✝ : ℕ
⊢ (m + n) % succ n✝ =
    if succ n✝ ≤ m % succ n✝ + n % succ n✝ then m % succ n✝ + n % succ n✝ - succ n✝ else m % succ n✝ + n % succ n✝

tactic: split_ifs with h
state_before: case succ
m n l n✝ : ℕ
⊢ (m % succ n✝ + n % succ n✝) % succ n✝ =
    if succ n✝ ≤ m % succ n✝ + n % succ n✝ then m % succ n✝ + n % succ n✝ - succ n✝ else m % succ n✝ + n % succ n✝

tactic: rw [Nat.mod_eq_sub_mod h, Nat.mod_eq_of_lt]
state_before: case succ.inl
m n l n✝ : ℕ
h : succ n✝ ≤ m % succ n✝ + n % succ n✝
⊢ (m % succ n✝ + n % succ n✝) % succ n✝ = m % succ n✝ + n % succ n✝ - succ n✝

tactic: exact
  (tsub_lt_iff_right h).mpr (Nat.add_lt_add (m.mod_lt (zero_lt_succ _))
    (n.mod_lt (zero_lt_succ _)))
state_before: case succ.inl
m n l n✝ : ℕ
h : succ n✝ ≤ m % succ n✝ + n % succ n✝
⊢ m % succ n✝ + n % succ n✝ - succ n✝ < succ n✝

tactic: exact Nat.mod_eq_of_lt (lt_of_not_ge h)
state_before: case succ.inr
m n l n✝ : ℕ
h : ¬succ n✝ ≤ m % succ n✝ + n % succ n✝
⊢ (m % succ n✝ + n % succ n✝) % succ n✝ = m % succ n✝ + n % succ n✝
Theorem: UniformFun.postcomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: refine uniformContinuous_iff.mpr ?_
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.39939
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ UniformContinuous (↑ofFun ∘ (fun x => f ∘ x) ∘ ↑toFun)

tactic: exact (UniformFun.mono (uniformContinuous_iff.mp hf)).trans_eq UniformFun.comap_eq
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.39939
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ uniformSpace α γ ≤ UniformSpace.comap (↑ofFun ∘ (fun x => f ∘ x) ∘ ↑toFun) (uniformSpace α β)
Theorem: Polynomial.IsWeaklyEisensteinAt.map
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

tactic: refine' (IsWeaklyEisensteinAt_iff _ _).2 fun hn => _
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ IsWeaklyEisensteinAt (Polynomial.map φ f) (Ideal.map φ 𝓟)

tactic: rw [coeff_map]
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < natDegree (Polynomial.map φ f)
⊢ coeff (Polynomial.map φ f) n✝ ∈ Ideal.map φ 𝓟

tactic: exact mem_map_of_mem _ (hf.mem (lt_of_lt_of_le hn (natDegree_map_le _ _)))
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < natDegree (Polynomial.map φ f)
⊢ ↑φ (coeff f n✝) ∈ Ideal.map φ 𝓟
Theorem: CategoryTheory.Arrow.square_to_iso_invert
File: Mathlib/CategoryTheory/Arrow.lean

tactic: simpa only [Category.assoc] using (Iso.comp_inv_eq p).mpr (Arrow.w_mk_right sq).symm
state_before: T : Type u
inst✝ : Category T
i : Arrow T
X Y : T
p : X ≅ Y
sq : i ⟶ mk p.hom
⊢ i.hom ≫ sq.right ≫ p.inv = sq.left
Theorem: Pretrivialization.symm_trans_target_eq
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [← LocalEquiv.symm_source, symm_trans_symm, symm_trans_source_eq, inter_comm]
state_before: ι : Type ?u.12276
B : Type u_1
F : Type u_2
E : B → Type ?u.12287
Z : Type u_3
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
⊢ (LocalEquiv.trans (LocalEquiv.symm e.toLocalEquiv) e'.toLocalEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ
Theorem: Pmf.mem_support_bernoulli_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp
state_before: α : Type ?u.170166
β : Type ?u.170169
γ : Type ?u.170172
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ b ∈ support (bernoulli p h) ↔ bif b then p ≠ 0 else p ≠ 1
Theorem: Nat.strongRecOn'_beta
File: Mathlib/Data/Nat/Basic.lean

tactic: simp only [strongRecOn']
state_before: m n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → ((m : ℕ) → m < n → P m) → P n
n : ℕ
⊢ strongRecOn' n h = h n fun m x => strongRecOn' m h

tactic: rw [Nat.strongRec']
state_before: m n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → ((m : ℕ) → m < n → P m) → P n
n : ℕ
⊢ Nat.strongRec' h n = h n fun m x => Nat.strongRec' h m
Theorem: Quiver.SingleObj.pathToList_listToPath
File: Mathlib/Combinatorics/Quiver/SingleObj.lean

tactic: induction' l with a l ih
state_before: α : Type u_1
β : Type ?u.5108
γ : Type ?u.5111
l : List α
⊢ pathToList (listToPath l) = l

tactic: rfl
state_before: case nil
α : Type u_1
β : Type ?u.5108
γ : Type ?u.5111
⊢ pathToList (listToPath []) = []

tactic: change a :: pathToList (listToPath l) = a :: l
state_before: case cons
α : Type u_1
β : Type ?u.5108
γ : Type ?u.5111
a : α
l : List α
ih : pathToList (listToPath l) = l
⊢ pathToList (listToPath (a :: l)) = a :: l

tactic: rw [ih]
state_before: case cons
α : Type u_1
β : Type ?u.5108
γ : Type ?u.5111
a : α
l : List α
ih : pathToList (listToPath l) = l
⊢ a :: pathToList (listToPath l) = a :: l
Theorem: Nat.ceil_add_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, Nat.cast_add]
state_before: F : Type ?u.92323
α : Type u_1
β : Type ?u.92329
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
⊢ ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊

tactic: exact _root_.add_le_add (le_ceil _) (le_ceil _)
state_before: F : Type ?u.92323
α : Type u_1
β : Type ?u.92329
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
⊢ a + b ≤ ↑⌈a⌉₊ + ↑⌈b⌉₊
Theorem: CategoryTheory.Limits.coprod.map_inl_inr_codiag
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ X Y : C
inst✝¹ : HasBinaryCoproduct X Y
inst✝ : HasBinaryCoproduct (X ⨿ Y) (X ⨿ Y)
⊢ map inl inr ≫ codiag (X ⨿ Y) = 𝟙 (X ⨿ Y)
Theorem: norm_div_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using dist_triangle a 1 b
state_before: 𝓕 : Type ?u.79045
𝕜 : Type ?u.79048
α : Type ?u.79051
ι : Type ?u.79054
κ : Type ?u.79057
E : Type u_1
F : Type ?u.79063
G : Type ?u.79066
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ ≤ ‖a‖ + ‖b‖
Theorem: LinearPMap.mem_graph_iff
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: cases x
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.477455
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E × F
⊢ x ∈ graph f ↔ ∃ y, ↑y = x.fst ∧ ↑f y = x.snd

tactic: simp_rw [mem_graph_iff', Prod.mk.inj_iff]
state_before: case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.477455
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
fst✝ : E
snd✝ : F
⊢ (fst✝, snd✝) ∈ graph f ↔ ∃ y, ↑y = (fst✝, snd✝).fst ∧ ↑f y = (fst✝, snd✝).snd
Theorem: NonUnitalAlgHom.snd_prod
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f : A →ₙₐ[R] B
g : A →ₙₐ[R] C
⊢ comp (snd R B C) (prod f g) = g
Theorem: Submodule.comap_unop_one
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [← map_equiv_eq_comap_symm, map_op_one]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ comap (↑(LinearEquiv.symm (opLinearEquiv R))) 1 = 1
Theorem: Real.iter_deriv_exp
File: Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean

tactic: rw [iterate_succ_apply, deriv_exp, iter_deriv_exp n]
state_before: x y z : ℝ
n : ℕ
⊢ (deriv^[n + 1]) exp = exp