tasksource/leandojo huggingface dataset:
Theorem: AdjoinRoot.algHom_subsingleton
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [← f.commutes, ← f.map_mul, algebraMap_eq, root_isInv, map_one]
state_before: R : Type u
S✝ : Type v
K : Type w
inst✝⁴ : CommRing R
f✝ : R[X]
inst✝³ : CommRing S✝
i : R →+* S✝
a : S✝
h : eval₂ i a f✝ = 0
inst✝² : Algebra R S✝
hfx : ↑(aeval a) f✝ = 0
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Algebra R S
r : R
f g : AdjoinRoot (↑C r * X - 1) →ₐ[R] S
⊢ ↑(algebraMap R S) r * ↑f (root (↑C r * X - 1)) = 1

tactic: rw [← g.commutes, ← g.map_mul, algebraMap_eq, root_isInv, map_one]
state_before: R : Type u
S✝ : Type v
K : Type w
inst✝⁴ : CommRing R
f✝ : R[X]
inst✝³ : CommRing S✝
i : R →+* S✝
a : S✝
h : eval₂ i a f✝ = 0
inst✝² : Algebra R S✝
hfx : ↑(aeval a) f✝ = 0
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Algebra R S
r : R
f g : AdjoinRoot (↑C r * X - 1) →ₐ[R] S
⊢ ↑(algebraMap R S) r * ↑g (root (↑C r * X - 1)) = 1
Theorem: PowerSeries.invUnitsSub_mul_sub
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: simp [mul_sub, sub_sub_cancel]
state_before: R : Type u_1
S : Type ?u.167170
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
⊢ invUnitsSub u * (↑(C R) ↑u - X) = 1
Theorem: Finmap.erase_erase
File: Mathlib/Data/Finmap.lean

tactic: simp only [AList.erase_erase, erase_toFinmap]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
s✝ : Finmap β
s : AList β
⊢ (erase a (erase a' ⟦s⟧)).entries = (erase a' (erase a ⟦s⟧)).entries
Theorem: LieModule.coe_maxTrivLinearMapEquivLieModuleHom
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: ext
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) = ↑↑f

tactic: rfl
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
x✝ : M
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑↑f x✝
Theorem: Cubic.natDegree_of_c_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_c_eq_zero ha hb hc, natDegree_C]
state_before: R : Type u_1
S : Type ?u.592326
F : Type ?u.592329
K : Type ?u.592332
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 0
⊢ natDegree (toPoly P) = 0
Theorem: MeasureTheory.Iio_ae_eq_Iic'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← Iic_diff_right, diff_ae_eq_self, measure_mono_null (Set.inter_subset_right _ _) ha]
state_before: α : Type u_1
β : Type ?u.595108
γ : Type ?u.595111
δ : Type ?u.595114
ι : Type ?u.595117
R : Type ?u.595120
R' : Type ?u.595123
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : PartialOrder α
a b : α
ha : ↑↑μ {a} = 0
⊢ Iio a =ᶠ[ae μ] Iic a
Theorem: CategoryTheory.Idempotents.Karoubi.p_comp
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rw [f.comm, ← assoc, P.idem]
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f : Hom P Q
⊢ P.p ≫ f.f = f.f
Theorem: Filter.mem_iSup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [← Filter.mem_sets, iSup_sets_eq, iff_self_iff, mem_iInter]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.66086
ι : Sort x
f✝ g : Filter α
s t x : Set α
f : ι → Filter α
⊢ x ∈ iSup f ↔ ∀ (i : ι), x ∈ f i
Theorem: Inducing.mapClusterPt_iff
File: Mathlib/Topology/Maps.lean

tactic: delta MapClusterPt ClusterPt
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3026
δ : Type ?u.3029
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
a : α
l : Filter α
⊢ MapClusterPt (f a) l f ↔ ClusterPt a l

tactic: rw [← Filter.push_pull', ← hf.nhds_eq_comap, map_neBot_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3026
δ : Type ?u.3029
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
a : α
l : Filter α
⊢ NeBot (𝓝 (f a) ⊓ map f l) ↔ NeBot (𝓝 a ⊓ l)
Theorem: tendsto_pow_div_pow_atTop_zero
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: rw [tendsto_congr' pow_div_pow_eventuallyEq_atTop]
state_before: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ Tendsto (fun x => x ^ p / x ^ q) atTop (𝓝 0)

tactic: apply tendsto_zpow_atTop_zero
state_before: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ Tendsto (fun x => x ^ (↑p - ↑q)) atTop (𝓝 0)

tactic: linarith
state_before: case hn
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ ↑p - ↑q < 0
Theorem: Set.exists_subset_or_subset_of_two_mul_lt_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: classical
have hu := Finite_of_ncard_ne_zero ((Nat.zero_le _).trans_lt hst).ne.symm
rw [ncard_eq_toFinset_card _ hu,
  Finite.toFinset_union (hu.subset (subset_union_left _ _))
    (hu.subset (subset_union_right _ _))] at hst
obtain ⟨r', hnr', hr'⟩ := Finset.exists_subset_or_subset_of_two_mul_lt_card hst
exact ⟨r', by simpa, by simpa using hr'⟩
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hst : 2 * n < ncard (s ∪ t)
⊢ ∃ r, n < ncard r ∧ (r ⊆ s ∨ r ⊆ t)

tactic: have hu := Finite_of_ncard_ne_zero ((Nat.zero_le _).trans_lt hst).ne.symm
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hst : 2 * n < ncard (s ∪ t)
⊢ ∃ r, n < ncard r ∧ (r ⊆ s ∨ r ⊆ t)

tactic: rw [ncard_eq_toFinset_card _ hu,
  Finite.toFinset_union (hu.subset (subset_union_left _ _))
    (hu.subset (subset_union_right _ _))] at hst
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hst : 2 * n < ncard (s ∪ t)
hu : Set.Finite (s ∪ t)
⊢ ∃ r, n < ncard r ∧ (r ⊆ s ∨ r ⊆ t)

tactic: obtain ⟨r', hnr', hr'⟩ := Finset.exists_subset_or_subset_of_two_mul_lt_card hst
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hu : Set.Finite (s ∪ t)
hst : 2 * n < Finset.card (Finite.toFinset (_ : Set.Finite s) ∪ Finite.toFinset (_ : Set.Finite t))
⊢ ∃ r, n < ncard r ∧ (r ⊆ s ∨ r ⊆ t)

tactic: exact ⟨r', by simpa, by simpa using hr'⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hu : Set.Finite (s ∪ t)
hst : 2 * n < Finset.card (Finite.toFinset (_ : Set.Finite s) ∪ Finite.toFinset (_ : Set.Finite t))
r' : Finset α
hnr' : n < Finset.card r'
hr' : r' ⊆ Finite.toFinset (_ : Set.Finite s) ∨ r' ⊆ Finite.toFinset (_ : Set.Finite t)
⊢ ∃ r, n < ncard r ∧ (r ⊆ s ∨ r ⊆ t)

tactic: simpa
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hu : Set.Finite (s ∪ t)
hst : 2 * n < Finset.card (Finite.toFinset (_ : Set.Finite s) ∪ Finite.toFinset (_ : Set.Finite t))
r' : Finset α
hnr' : n < Finset.card r'
hr' : r' ⊆ Finite.toFinset (_ : Set.Finite s) ∨ r' ⊆ Finite.toFinset (_ : Set.Finite t)
⊢ n < ncard ↑r'

tactic: simpa using hr'
state_before: α : Type u_1
β : Type ?u.137499
s t : Set α
a b x y : α
f : α → β
n : ℕ
hu : Set.Finite (s ∪ t)
hst : 2 * n < Finset.card (Finite.toFinset (_ : Set.Finite s) ∪ Finite.toFinset (_ : Set.Finite t))
r' : Finset α
hnr' : n < Finset.card r'
hr' : r' ⊆ Finite.toFinset (_ : Set.Finite s) ∨ r' ⊆ Finite.toFinset (_ : Set.Finite t)
⊢ ↑r' ⊆ s ∨ ↑r' ⊆ t
Theorem: Real.cos_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: exact_mod_cast @Complex.cos_eq_zero_iff θ
state_before: θ : ℝ
⊢ cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * π / 2
Theorem: SignType.neg_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a < 0 ↔ a = -1
Theorem: ZFSet.toSet_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: x : ZFSet
⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x)

tactic: simp
state_before: case h
x x✝ : ZFSet
⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x)
Theorem: Nat.cauchy_induction'
File: Mathlib/Data/Nat/Interval.lean

tactic: apply Nat.decreasing_induction_of_infinite h fun hf => _
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
⊢ P n

tactic: intro hf
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
⊢ Set.Finite {x | P x} → False

tactic: obtain ⟨m, hP, hm⟩ := hf.exists_maximal_wrt id _ ⟨seed, hs⟩
state_before: a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : Set.Finite {x | P x}
⊢ False

tactic: obtain ⟨y, hl, hy⟩ := hi m (le_of_not_lt fun hl => hl.ne <| hm seed hs hl.le) hP
state_before: case intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : Set.Finite {x | P x}
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ (a' : ℕ), a' ∈ {x | P x} → id m ≤ id a' → id m = id a'
⊢ False

tactic: exact hl.ne (hm y hy hl.le)
state_before: case intro.intro.intro.intro
a b c : ℕ
P : ℕ → Prop
h : ∀ (n : ℕ), P (n + 1) → P n
seed : ℕ
hs : P seed
hi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y
n : ℕ
hf : Set.Finite {x | P x}
m : ℕ
hP : m ∈ {x | P x}
hm : ∀ (a' : ℕ), a' ∈ {x | P x} → id m ≤ id a' → id m = id a'
y : ℕ
hl : m < y
hy : P y
⊢ False
Theorem: Nat.frequently_modEq
File: Mathlib/Order/Filter/ModEq.lean

tactic: simp [Nat.modEq_iff_dvd, ← sub_sub]
state_before: n : ℕ
h : n ≠ 0
d m : ℕ
⊢ ((fun a => a + d) ∘ fun x => n • id x) m ≡ d [MOD n]
Theorem: Rat.ofScientific_true_def
File: Std/Data/Rat/Lemmas.lean

tactic: unfold Rat.ofScientific
state_before: m e : Nat
⊢ Rat.ofScientific m true e = mkRat (↑m) (10 ^ e)

tactic: rw [normalize_eq_mkRat]
state_before: m e : Nat
⊢ (if true = true then normalize (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)

tactic: rfl
state_before: m e : Nat
⊢ (if true = true then mkRat (↑m) (10 ^ e) else ↑↑(m * 10 ^ e)) = mkRat (↑m) (10 ^ e)
Theorem: strictConvex_closedBall
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: cases' le_or_lt r 0 with hr hr
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : StrictConvexSpace 𝕜 E
x : E
r : ℝ
⊢ StrictConvex 𝕜 (closedBall x r)

tactic: rw [← vadd_closedBall_zero]
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : StrictConvexSpace 𝕜 E
x : E
r : ℝ
hr : 0 < r
⊢ StrictConvex 𝕜 (closedBall x r)

tactic: exact (StrictConvexSpace.strictConvex_closedBall r hr).vadd _
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : StrictConvexSpace 𝕜 E
x : E
r : ℝ
hr : 0 < r
⊢ StrictConvex 𝕜 (x +ᵥ closedBall 0 r)

tactic: exact (subsingleton_closedBall x hr).strictConvex
state_before: case inl
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : StrictConvexSpace 𝕜 E
x : E
r : ℝ
hr : r ≤ 0
⊢ StrictConvex 𝕜 (closedBall x r)
Theorem: div_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_le_div_iff (hd.trans_le hbd) hd]
state_before: ι : Type ?u.69452
α : Type u_1
β : Type ?u.69458
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a / b ≤ c / d

tactic: exact mul_le_mul hac hbd hd.le hc
state_before: ι : Type ?u.69452
α : Type u_1
β : Type ?u.69458
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a * d ≤ c * b
Theorem: Set.image2_subset_iff_right
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [image2_subset_iff, image_subset_iff, subset_def, mem_preimage, @forall₂_swap α]
state_before: α : Type u_2
α' : Type ?u.4764
β : Type u_3
β' : Type ?u.4770
γ : Type u_1
γ' : Type ?u.4776
δ : Type ?u.4779
δ' : Type ?u.4782
ε : Type ?u.4785
ε' : Type ?u.4788
ζ : Type ?u.4791
ζ' : Type ?u.4794
ν : Type ?u.4797
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s t ⊆ u ↔ ∀ (b : β), b ∈ t → (fun a => f a b) '' s ⊆ u
Theorem: Set.subsingleton_coe
File: Mathlib/Data/Set/Basic.lean

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ Subsingleton ↑s ↔ Set.Subsingleton s

tactic: refine' fun h => fun a ha b hb => _
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ Subsingleton ↑s → Set.Subsingleton s

tactic: exact SetCoe.ext_iff.2 (@Subsingleton.elim s h ⟨a, ha⟩ ⟨b, hb⟩)
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b✝ : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
h : Subsingleton ↑s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ a = b

tactic: exact fun h => Subsingleton.intro fun a b => SetCoe.ext (h a.property b.property)
state_before: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ Set.Subsingleton s → Subsingleton ↑s
Theorem: CategoryTheory.natIsoOfCompFullyFaithful_hom
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: ext
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u_2
inst✝² : Category E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
⊢ (natIsoOfCompFullyFaithful H i).hom = natTransOfCompFullyFaithful H i.hom

tactic: simp [natIsoOfCompFullyFaithful]
state_before: case w.h
C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
E : Type u_2
inst✝² : Category E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
x✝ : C
⊢ (natIsoOfCompFullyFaithful H i).hom.app x✝ = (natTransOfCompFullyFaithful H i.hom).app x✝
Theorem: HasDerivWithinAt.comp
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: rw [mul_comm]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
hh₂ : HasDerivWithinAt h₂ h₂' s' (h x)
hh : HasDerivWithinAt h h' s x
hst : MapsTo h s s'
⊢ HasDerivWithinAt (h₂ ∘ h) (h₂' * h') s x

tactic: exact hh₂.scomp x hh hst
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
hh₂ : HasDerivWithinAt h₂ h₂' s' (h x)
hh : HasDerivWithinAt h h' s x
hst : MapsTo h s s'
⊢ HasDerivWithinAt (h₂ ∘ h) (h' * h₂') s x
Theorem: List.prefix_concat
File: Mathlib/Data/List/Infix.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.160
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
⊢ l <+: concat l a
Theorem: MonoidHom.coprod_unique
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp [coprod_apply, inl_apply, inr_apply, ← map_mul]
state_before: A : Type ?u.68969
B : Type ?u.68972
G : Type ?u.68975
H : Type ?u.68978
M : Type u_2
N : Type u_1
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommMonoid P
f✝ : M →* P
g : N →* P
f : M × N →* P
x : M × N
⊢ ↑(coprod (comp f (inl M N)) (comp f (inr M N))) x = ↑f x
Theorem: Real.sq_sin_pi_div_three
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_pi_div_two_sub, ← sq_cos_pi_div_six]
state_before: x : ℝ
⊢ sin (π / 3) ^ 2 = 3 / 4

tactic: congr
state_before: x : ℝ
⊢ cos (π / 2 - π / 3) ^ 2 = cos (π / 6) ^ 2

tactic: ring
state_before: case e_a.e_x
x : ℝ
⊢ π / 2 - π / 3 = π / 6
Theorem: Function.mem_fixedPoints_iff
File: Mathlib/Dynamics/FixedPoints/Basic.lean

tactic: rfl
state_before: α✝ : Type u
β : Type v
f✝ fa g : α✝ → α✝
x✝ y : α✝
fb : β → β
m n k : ℕ
e : Perm α✝
α : Type u_1
f : α → α
x : α
⊢ x ∈ fixedPoints f ↔ f x = x
Theorem: FirstOrder.Language.Substructure.mem_closure_iff_exists_term
File: Mathlib/ModelTheory/Substructures.lean

tactic: rw [← SetLike.mem_coe, coe_closure_eq_range_term_realize, mem_range]
state_before: L : Language
M : Type w
N : Type ?u.33484
P : Type ?u.33487
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
s : Set M
x : M
⊢ x ∈ LowerAdjoint.toFun (closure L) s ↔ ∃ t, Term.realize Subtype.val t = x
Theorem: Subsemigroup.mem_sSup_of_mem
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: have : s ≤ sSup S := le_sSup hs
state_before: ι : Sort ?u.8999
M : Type u_1
A : Type ?u.9005
B : Type ?u.9008
inst✝ : Mul M
S : Set (Subsemigroup M)
s : Subsemigroup M
hs : s ∈ S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: tauto
state_before: ι : Sort ?u.8999
M : Type u_1
A : Type ?u.9005
B : Type ?u.9008
inst✝ : Mul M
S : Set (Subsemigroup M)
s : Subsemigroup M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
Theorem: LinearMap.ker_codRestrict
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [ker, comap_codRestrict, Submodule.map_bot]
state_before: R : Type u_2
R₁ : Type ?u.1232780
R₂ : Type u_1
R₃ : Type ?u.1232786
R₄ : Type ?u.1232789
S : Type ?u.1232792
K : Type ?u.1232795
K₂ : Type ?u.1232798
M : Type u_3
M' : Type ?u.1232804
M₁ : Type ?u.1232807
M₂ : Type u_4
M₃ : Type ?u.1232813
M₄ : Type ?u.1232816
N : Type ?u.1232819
N₂ : Type ?u.1232822
ι : Type ?u.1232825
V : Type ?u.1232828
V₂ : Type ?u.1232831
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.1233241
sc : SemilinearMapClass F τ₁₂ M M₂
τ₂₁ : R₂ →+* R
p : Submodule R M
f : M₂ →ₛₗ[τ₂₁] M
hf : ∀ (c : M₂), ↑f c ∈ p
⊢ ker (codRestrict p f hf) = ker f

tactic: rfl
state_before: R : Type u_2
R₁ : Type ?u.1232780
R₂ : Type u_1
R₃ : Type ?u.1232786
R₄ : Type ?u.1232789
S : Type ?u.1232792
K : Type ?u.1232795
K₂ : Type ?u.1232798
M : Type u_3
M' : Type ?u.1232804
M₁ : Type ?u.1232807
M₂ : Type u_4
M₃ : Type ?u.1232813
M₄ : Type ?u.1232816
N : Type ?u.1232819
N₂ : Type ?u.1232822
ι : Type ?u.1232825
V : Type ?u.1232828
V₂ : Type ?u.1232831
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.1233241
sc : SemilinearMapClass F τ₁₂ M M₂
τ₂₁ : R₂ →+* R
p : Submodule R M
f : M₂ →ₛₗ[τ₂₁] M
hf : ∀ (c : M₂), ↑f c ∈ p
⊢ comap f ⊥ = ker f
Theorem: Basis.det_unitsSMul_self
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp [Basis.det_apply]
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2918948
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_3
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type ?u.2919968
inst✝¹ : CommRing A
inst✝ : Module A M
w : ι → Rˣ
⊢ ↑(det e) ↑(unitsSMul e w) = ∏ i : ι, ↑(w i)
Theorem: Stream'.WSeq.join_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [think, join]
state_before: α : Type u
β : Type v
γ : Type w
S : WSeq (WSeq α)
⊢ join (think S) = think (join S)

tactic: simp [join, Seq1.ret]
state_before: α : Type u
β : Type v
γ : Type w
S : WSeq (WSeq α)
⊢ Seq.join
      (Seq.map
        (fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s))
        (Seq.cons none S)) =
    Seq.cons none
      (Seq.join
        (Seq.map
          (fun o =>
            match o with
            | none => Seq1.ret none
            | some s => (none, s))
          S))
Theorem: isCompact_univ_pi
File: Mathlib/Topology/SubsetProperties.lean

tactic: convert isCompact_pi_infinite h
state_before: α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s✝ t : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : (i : ι) → Set (π i)
h : ∀ (i : ι), IsCompact (s i)
⊢ IsCompact (Set.pi univ s)

tactic: simp only [← mem_univ_pi, setOf_mem_eq]
state_before: case h.e'_3
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s✝ t : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : (i : ι) → Set (π i)
h : ∀ (i : ι), IsCompact (s i)
⊢ Set.pi univ s = {x | ∀ (i : ι), x i ∈ s i}
Theorem: Antivary.card_smul_sum_le_sum_smul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: refine (hfg.dual_right.monovaryOn _).sum_smul_sum_le_card_smul_sum
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 : Antivary f g
⊢ Fintype.card ι • ∑ i : ι, f i • g i ≤ (∑ i : ι, f i) • ∑ i : ι, g i
Theorem: MeasurableSpace.cardinal_generateMeasurable_le
File: Mathlib/MeasureTheory/CardMeasurableSpace.lean

tactic: rw [generateMeasurable_eq_rec]
state_before: α : Type u
s : Set (Set α)
⊢ (#↑{t | GenerateMeasurable s t}) ≤ max (#↑s) 2 ^ ℵ₀

tactic: apply (mk_iUnion_le _).trans
state_before: α : Type u
s : Set (Set α)
⊢ (#↑(⋃ (i : (Quotient.out (ord (aleph 1))).α), generateMeasurableRec s i)) ≤ max (#↑s) 2 ^ ℵ₀

tactic: rw [(aleph 1).mk_ord_out]
state_before: α : Type u
s : Set (Set α)
⊢ ((#(Quotient.out (ord (aleph 1))).α) * ⨆ (i : (Quotient.out (ord (aleph 1))).α), #↑(generateMeasurableRec s i)) ≤
    max (#↑s) 2 ^ ℵ₀

tactic: refine le_trans (mul_le_mul' aleph_one_le_continuum
    (ciSup_le' fun i => cardinal_generateMeasurableRec_le s i)) ?_
state_before: α : Type u
s : Set (Set α)
⊢ (aleph 1 * ⨆ (i : (Quotient.out (ord (aleph 1))).α), #↑(generateMeasurableRec s i)) ≤ max (#↑s) 2 ^ ℵ₀

tactic: refine (mul_le_max_of_aleph0_le_left aleph0_le_continuum).trans (max_le ?_ le_rfl)
state_before: α : Type u
s : Set (Set α)
⊢ 𝔠 * max (#↑s) 2 ^ ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀

tactic: exact power_le_power_right (le_max_right _ _)
state_before: α : Type u
s : Set (Set α)
⊢ 𝔠 ≤ max (#↑s) 2 ^ ℵ₀
Theorem: Nat.odd_of_mod_four_eq_three
File: Mathlib/Data/Nat/ModEq.lean

tactic: simpa [ModEq, show 2 * 2 = 4 by norm_num, show 3 % 4 = 3 by norm_num] using
  @ModEq.of_mul_left 2 n 3 2
state_before: m n✝ a b c d n : ℕ
⊢ n % 4 = 3 → n % 2 = 1

tactic: norm_num
state_before: m n✝ a b c d n : ℕ
⊢ 2 * 2 = 4

tactic: norm_num
state_before: m n✝ a b c d n : ℕ
⊢ 3 % 4 = 3
Theorem: Stirling.log_stirlingSeq_bounded_by_constant
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: obtain ⟨d, h⟩ := log_stirlingSeq_bounded_aux
state_before: ⊢ ∃ c, ∀ (n : ℕ), c ≤ Real.log (stirlingSeq (succ n))

tactic: exact ⟨log (stirlingSeq 1) - d, fun n => sub_le_comm.mp (h n)⟩
state_before: case intro
d : ℝ
h : ∀ (n : ℕ), Real.log (stirlingSeq 1) - Real.log (stirlingSeq (succ n)) ≤ d
⊢ ∃ c, ∀ (n : ℕ), c ≤ Real.log (stirlingSeq (succ n))