tasksource/leandojo huggingface dataset:
Theorem: BumpCovering.exists_isSubordinate
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: rcases precise_refinement_set hs _ ho hU with ⟨V, hVo, hsV, hVf, hVU⟩
state_before: ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
⊢ ∃ f, IsSubordinate f U

tactic: rcases exists_isSubordinate_of_locallyFinite hs V hVo hVf hsV with ⟨f, hf⟩
state_before: case intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ (i : ι), V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
⊢ ∃ f, IsSubordinate f U

tactic: exact ⟨f, hf.mono hVU⟩
state_before: case intro.intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f✝ : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ (i : ι), V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
f : BumpCovering ι X s
hf : IsSubordinate f V
⊢ ∃ f, IsSubordinate f U
Theorem: Euclidean.closedBall_eq_image
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [toEuclidean.image_symm_eq_preimage, closedBall_eq_preimage]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ closedBall x r = ↑(ContinuousLinearEquiv.symm toEuclidean) '' Metric.closedBall (↑toEuclidean x) r
Theorem: Monovary.sum_smul_comp_perm_lt_sum_smul_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.monovaryOn _).sum_smul_comp_perm_lt_sum_smul_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Monovary f g
⊢ ∑ i : ι, f i • g (↑σ i) < ∑ i : ι, f i • g i ↔ ¬Monovary f (g ∘ ↑σ)
Theorem: starConvex_iff_pointwise_add_subset
File: Mathlib/Analysis/Convex/Star.lean

tactic: refine'
  ⟨_, fun h y hy a b ha hb hab =>
    h ha hb hab (add_mem_add (smul_mem_smul_set <| mem_singleton _) ⟨_, hy, rfl⟩)⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3397
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
⊢ StarConvex 𝕜 x s ↔ ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → a • {x} + b • s ⊆ s

tactic: rintro hA a b ha hb hab w ⟨au, bv, ⟨u, rfl : u = x, rfl⟩, ⟨v, hv, rfl⟩, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3397
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
⊢ StarConvex 𝕜 x s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → a • {x} + b • s ⊆ s

tactic: exact hA hv ha hb hab
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3397
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s t : Set E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
u : E
hA : StarConvex 𝕜 u s
v : E
hv : v ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => a • x) u) ((fun x => b • x) v) ∈ s
Theorem: Polynomial.toFinsupp_C_mul_X_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [C_mul_X_pow_eq_monomial, toFinsupp_monomial]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
n : ℕ
⊢ (↑C a * X ^ n).toFinsupp = Finsupp.single n a
Theorem: SemiconjBy.add_left
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simp only [SemiconjBy, left_distrib, right_distrib, ha.eq, hb.eq]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Distrib R
a b x y : R
ha : SemiconjBy a x y
hb : SemiconjBy b x y
⊢ SemiconjBy (a + b) x y
Theorem: smul_finsum
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rcases eq_or_ne c 0 with (rfl | hc)
state_before: G : Type ?u.155974
M✝ : Type ?u.155977
N : Type ?u.155980
α : Sort ?u.155983
β : Sort ?u.155986
ι : Sort u_3
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_1
M : Type u_2
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
c : R
f : ι → M
⊢ (c • ∑ᶠ (i : ι), f i) = ∑ᶠ (i : ι), c • f i

tactic: exact (smulAddHom R M c).map_finsum_of_injective (smul_right_injective M hc) _
state_before: case inr
G : Type ?u.155974
M✝ : Type ?u.155977
N : Type ?u.155980
α : Sort ?u.155983
β : Sort ?u.155986
ι : Sort u_3
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_1
M : Type u_2
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
c : R
f : ι → M
hc : c ≠ 0
⊢ (c • ∑ᶠ (i : ι), f i) = ∑ᶠ (i : ι), c • f i

tactic: simp
state_before: case inl
G : Type ?u.155974
M✝ : Type ?u.155977
N : Type ?u.155980
α : Sort ?u.155983
β : Sort ?u.155986
ι : Sort u_3
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_1
M : Type u_2
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
f : ι → M
⊢ (0 • ∑ᶠ (i : ι), f i) = ∑ᶠ (i : ι), 0 • f i
Theorem: Group.closure_subset
File: Mathlib/Deprecated/Subgroup.lean

tactic: induction ha <;> simp [h _, *, ht.one_mem, ht.mul_mem, IsSubgroup.inv_mem_iff]
state_before: G : Type u_1
H : Type ?u.121913
A : Type ?u.121916
a✝ a₁ a₂ b c : G
inst✝ : Group G
s✝ s t : Set G
ht : IsSubgroup t
h : s ⊆ t
a : G
ha : a ∈ closure s
⊢ a ∈ t
Theorem: CategoryTheory.unitCompPartialBijective_natural
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: rw [← Equiv.eq_symm_apply, unitCompPartialBijective_symm_natural A h, Equiv.symm_apply_apply]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A B B' : C
h : B ⟶ B'
hB : B ∈ Functor.essImage i
hB' : B' ∈ Functor.essImage i
f : A ⟶ B
⊢ ↑(unitCompPartialBijective A hB') (f ≫ h) = ↑(unitCompPartialBijective A hB) f ≫ h
Theorem: deriv.lhopital_zero_nhds
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: apply lhopital_zero_nhds' <;>
  (first | apply eventually_nhdsWithin_of_eventually_nhds |
    apply tendsto_nhdsWithin_of_tendsto_nhds) <;> assumption
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[{a}ᶜ] a) l

tactic: first | apply eventually_nhdsWithin_of_eventually_nhds |
 apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv (fun x => f x) x / deriv (fun x => g x) x) (𝓝[{a}ᶜ] a) l

tactic: apply eventually_nhdsWithin_of_eventually_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv (fun x => f x) x / deriv (fun x => g x) x) (𝓝[{a}ᶜ] a) l

tactic: apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv (fun x => f x) x / deriv (fun x => g x) x) (𝓝[{a}ᶜ] a) l
Theorem: FormalMultilinearSeries.le_radius_of_summable
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simp only [← coe_nnnorm] at h
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.84148
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : Summable fun n => ‖p n‖ * ↑r ^ n
⊢ Summable fun n => ‖p n‖₊ * r ^ n

tactic: exact_mod_cast h
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.84148
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : Summable fun n => ↑‖p n‖₊ * ↑r ^ n
⊢ Summable fun n => ‖p n‖₊ * r ^ n
Theorem: Cardinal.le_aleph0_iff_set_countable
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [mk_le_aleph0_iff, countable_coe_iff]
state_before: α β : Type u
s : Set α
⊢ (#↑s) ≤ ℵ₀ ↔ Set.Countable s
Theorem: Int.add_le_of_le_sub_left
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_le_add_left h a
state_before: a b c : Int
h : b ≤ c - a
⊢ a + b ≤ c

tactic: rwa [← Int.add_sub_assoc, Int.add_comm a c, Int.add_sub_cancel] at h
state_before: a b c : Int
h✝ : b ≤ c - a
h : a + b ≤ a + (c - a)
⊢ a + b ≤ c
Theorem: AddCircle.coe_real_preimage_closedBall_period_zero
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: ext y
state_before: p x ε : ℝ
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε = closedBall x ε

tactic: simp only [Set.mem_preimage, dist_eq_norm, AddCircle.norm_eq_of_zero, iff_self,
  ← QuotientAddGroup.mk_sub, Metric.mem_closedBall, Real.norm_eq_abs]
state_before: case h
p x ε y : ℝ
⊢ y ∈ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ↔ y ∈ closedBall x ε
Theorem: geom_sum_one
File: Mathlib/Algebra/GeomSum.lean

tactic: simp [geom_sum_succ']
state_before: α : Type u
inst✝ : Semiring α
x : α
⊢ ∑ i in range 1, x ^ i = 1
Theorem: LinearMap.range_eq_bot
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← range_le_bot_iff, le_bot_iff]
state_before: R : Type u_1
R₁ : Type ?u.1257644
R₂ : Type u_2
R₃ : Type ?u.1257650
R₄ : Type ?u.1257653
S : Type ?u.1257656
K : Type ?u.1257659
K₂ : Type ?u.1257662
M : Type u_3
M' : Type ?u.1257668
M₁ : Type ?u.1257671
M₂ : Type u_4
M₃ : Type ?u.1257677
M₄ : Type ?u.1257680
N : Type ?u.1257683
N₂ : Type ?u.1257686
ι : Type ?u.1257689
V : Type ?u.1257692
V₂ : Type ?u.1257695
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type ?u.1258105
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
⊢ range f = ⊥ ↔ f = 0
Theorem: LinearMap.pow_eq_aeval_mod_charpoly
File: Mathlib/LinearAlgebra/Charpoly/Basic.lean

tactic: rw [← aeval_eq_aeval_mod_charpoly, map_pow, aeval_X]
state_before: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : Nontrivial R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
f : M →ₗ[R] M
k : ℕ
⊢ f ^ k = ↑(aeval f) (X ^ k %ₘ charpoly f)
Theorem: ProbabilityTheory.IndepSets.iUnion
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro t1 t2 ht1 ht2
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
hyp : ∀ (n : ι), IndepSets (s n) s'
⊢ IndepSets (⋃ (n : ι), s n) s'

tactic: rw [Set.mem_iUnion] at ht1
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
hyp : ∀ (n : ι), IndepSets (s n) s'
t1 t2 : Set Ω
ht1 : t1 ∈ ⋃ (n : ι), s n
ht2 : t2 ∈ s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: cases' ht1 with n ht1
state_before: Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
hyp : ∀ (n : ι), IndepSets (s n) s'
t1 t2 : Set Ω
ht1 : ∃ i, t1 ∈ s i
ht2 : t2 ∈ s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact hyp n t1 t2 ht1 ht2
state_before: case intro
Ω : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace Ω
s : ι → Set (Set Ω)
s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
hyp : ∀ (n : ι), IndepSets (s n) s'
t1 t2 : Set Ω
ht2 : t2 ∈ s'
n : ι
ht1 : t1 ∈ s n
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2
Theorem: Finsupp.sum_mul
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp only [Finsupp.sum, Finset.sum_mul]
state_before: α : Type u_1
ι : Type ?u.627194
γ : Type ?u.627197
A : Type ?u.627200
B : Type ?u.627203
C : Type ?u.627206
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.630336
M : Type ?u.630339
M' : Type ?u.630342
N : Type ?u.630345
P : Type ?u.630348
G : Type ?u.630351
H : Type ?u.630354
R : Type u_2
S : Type u_3
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NonUnitalNonAssocSemiring S
b : S
s : α →₀ R
f : α → R → S
⊢ sum s f * b = sum s fun a c => f a c * b
Theorem: padicValRat.of_nat
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValRat]
state_before: p n : ℕ
⊢ padicValRat p ↑n = ↑(padicValNat p n)
Theorem: MeasureTheory.set_lintegral_const_lt_top
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_const]
state_before: α : Type u_1
β : Type ?u.76135
γ : Type ?u.76138
δ : Type ?u.76141
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
s : Set α
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ (∫⁻ (x : α) in s, c ∂μ) < ⊤

tactic: exact ENNReal.mul_lt_top hc (measure_ne_top (μ.restrict s) univ)
state_before: α : Type u_1
β : Type ?u.76135
γ : Type ?u.76138
δ : Type ?u.76141
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
s : Set α
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c * ↑↑(Measure.restrict μ s) univ < ⊤
Theorem: div_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_inv_eq_iff_eq_mul]
state_before: α : Type ?u.62542
β : Type ?u.62545
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a / b = c ↔ a = c * b
Theorem: Function.iterate_pred_comp_of_pos
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [← iterate_succ, Nat.succ_pred_eq_of_pos hn]
state_before: α : Type u
β : Type v
f : α → α
n : ℕ
hn : 0 < n
⊢ f^[Nat.pred n] ∘ f = f^[n]
Theorem: HahnSeries.single_coeff
File: Mathlib/RingTheory/HahnSeries.lean

tactic: split_ifs with h <;> simp [h]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
⊢ coeff (↑(single a) r) b = if b = a then r else 0
Theorem: Function.Commute.invOn_fixedPoints_comp
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: simpa only [h.comp_eq] using Function.invOn_fixedPoints_comp f g
state_before: α : Type u
β : Type v
f fa g : α → α
x y : α
fb : β → β
m n k : ℕ
e : Perm α
h : Commute f g
⊢ Set.InvOn f g (fixedPoints (f ∘ g)) (fixedPoints (f ∘ g))
Theorem: CategoryTheory.Functor.reflectsMonomorphisms.of_iso
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: apply F.mono_of_mono_map
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : ReflectsMonomorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
⊢ Mono f

tactic: haveI : Mono (G.map f ≫ (α.app Y).inv) := mono_comp _ _
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : ReflectsMonomorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
⊢ Mono (F.map f)

tactic: convert (mono_comp _ _ : Mono ((α.app X).hom ≫ G.map f ≫ (α.app Y).inv))
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : ReflectsMonomorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ Mono (F.map f)

tactic: rw [← Category.assoc, Iso.eq_comp_inv, Iso.app_hom, Iso.app_hom, NatTrans.naturality]
state_before: case h.e'_5
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
inst✝ : ReflectsMonomorphisms F
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ F.map f = (α.app X).hom ≫ G.map f ≫ (α.app Y).inv
Theorem: reflection_eq_self_iff
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← orthogonalProjection_eq_self_iff, reflection_apply, sub_eq_iff_eq_add', ← two_smul 𝕜,
  two_smul ℕ, ← two_smul 𝕜]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.708393
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
⊢ ↑(reflection K) x = x ↔ x ∈ K

tactic: refine' (smul_right_injective E _).eq_iff
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.708393
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
⊢ 2 • ↑(↑(orthogonalProjection K) x) = 2 • x ↔ ↑(↑(orthogonalProjection K) x) = x

tactic: exact two_ne_zero
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.708393
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x : E
⊢ 2 ≠ 0
Theorem: Dense.eq_zero_of_mem_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rwa [sub_zero]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.895794
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
inst✝ : CompleteSpace E
hK : Dense ↑K
h : x ∈ Kᗮ
⊢ x - 0 ∈ Kᗮ
Theorem: Irrational.mul_int
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_int]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑m)

tactic: refine' h.mul_rat _
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑↑m)

tactic: rwa [Int.cast_ne_zero]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ ↑m ≠ 0
Theorem: CategoryTheory.Comma.eqToHom_left
File: Mathlib/CategoryTheory/Comma.lean

tactic: cases H
state_before: A : Type u₁
inst✝² : Category A
B : Type u₂
inst✝¹ : Category B
T : Type u₃
inst✝ : Category T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ X.left = Y.left

tactic: rfl
state_before: case refl
A : Type u₁
inst✝² : Category A
B : Type u₂
inst✝¹ : Category B
T : Type u₃
inst✝ : Category T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.left = X.left

tactic: cases H
state_before: A : Type u₁
inst✝² : Category A
B : Type u₂
inst✝¹ : Category B
T : Type u₃
inst✝ : Category T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ (eqToHom H).left = eqToHom (_ : X.left = Y.left)

tactic: rfl
state_before: case refl
A : Type u₁
inst✝² : Category A
B : Type u₂
inst✝¹ : Category B
T : Type u₃
inst✝ : Category T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom (_ : X = X)).left = eqToHom (_ : X.left = X.left)
Theorem: pow_le_pow_of_le_left'
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simp
state_before: β : Type ?u.717
A : Type ?u.720
G : Type ?u.723
M : Type u_1
R : Type ?u.729
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
⊢ a ^ 0 ≤ b ^ 0

tactic: rw [pow_succ, pow_succ]
state_before: β : Type ?u.717
A : Type ?u.720
G : Type ?u.723
M : Type u_1
R : Type ?u.729
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
k : ℕ
⊢ a ^ (k + 1) ≤ b ^ (k + 1)

tactic: exact mul_le_mul' hab (pow_le_pow_of_le_left' hab k)
state_before: β : Type ?u.717
A : Type ?u.720
G : Type ?u.723
M : Type u_1
R : Type ?u.729
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : M
hab : a ≤ b
k : ℕ
⊢ a * a ^ k ≤ b * b ^ k
Theorem: Polynomial.degree_mul_C
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [degree_mul, degree_C a0, add_zero]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a0 : a ≠ 0
⊢ degree (p * ↑C a) = degree p
Theorem: RelEmbedding.not_acc_of_decreasing_seq
File: Mathlib/Order/OrderIsoNat.lean

tactic: rw [acc_iff_no_decreasing_seq, not_isEmpty_iff]
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
f : (fun x x_1 => x > x_1) ↪r r
k : ℕ
⊢ ¬Acc r (↑f k)

tactic: exact ⟨⟨f, k, rfl⟩⟩
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
f : (fun x x_1 => x > x_1) ↪r r
k : ℕ
⊢ Nonempty { f_1 // ↑f k ∈ Set.range ↑f_1 }
Theorem: Nat.succ_div_of_not_dvd
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rw [succ_div, if_neg hba, add_zero]
state_before: a✝ b✝ m n k a b : ℕ
hba : ¬b ∣ a + 1
⊢ (a + 1) / b = a / b
Theorem: List.take_replicate
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.160293
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
⊢ take n (replicate 0 a) = replicate (min n 0) a

tactic: simp
state_before: ι : Type ?u.160293
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
m : ℕ
⊢ take 0 (replicate m a) = replicate (min 0 m) a

tactic: simp [min_succ_succ, take_replicate]
state_before: ι : Type ?u.160293
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n m : ℕ
⊢ take (succ n) (replicate (succ m) a) = replicate (min (succ n) (succ m)) a
Theorem: Nat.dvd_iff_dvd_digits_sum
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [← ofDigits_one]
state_before: n✝ b b' : ℕ
h : b' % b = 1
n : ℕ
⊢ b ∣ n ↔ b ∣ List.sum (digits b' n)

tactic: conv_lhs => rw [← ofDigits_digits b' n]
state_before: n✝ b b' : ℕ
h : b' % b = 1
n : ℕ
⊢ b ∣ n ↔ b ∣ ofDigits 1 (digits b' n)

tactic: rw [Nat.dvd_iff_mod_eq_zero, Nat.dvd_iff_mod_eq_zero, ofDigits_mod, h]
state_before: n✝ b b' : ℕ
h : b' % b = 1
n : ℕ
⊢ b ∣ ofDigits b' (digits b' n) ↔ b ∣ ofDigits 1 (digits b' n)