tasksource/leandojo huggingface dataset:
Theorem: StarSubalgebra.closedEmbedding_inclusion
File: Mathlib/Topology/Algebra/StarSubalgebra.lean

tactic: convert(Set.range_subtype_map id _).symm
state_before: R : Type u_1
A : Type u_2
B : Type ?u.20732
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
src✝ : Embedding ↑(inclusion h) := embedding_inclusion h
⊢ Subtype.val ⁻¹' ↑S₁ = range ↑(inclusion h)

tactic: rw [Set.image_id]
state_before: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type ?u.20732
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
src✝ : Embedding ↑(inclusion h) := embedding_inclusion h
⊢ ↑S₁ = id '' {x | x ∈ S₁}

tactic: rfl
state_before: case h.e'_2.h.e'_4
R : Type u_1
A : Type u_2
B : Type ?u.20732
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
src✝ : Embedding ↑(inclusion h) := embedding_inclusion h
⊢ ↑S₁ = {x | x ∈ S₁}

tactic: intro _ h'
state_before: case convert_4
R : Type u_1
A : Type u_2
B : Type ?u.20732
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
src✝ : Embedding ↑(inclusion h) := embedding_inclusion h
⊢ ∀ (x : A), x ∈ S₁ → id x ∈ S₂

tactic: apply h h'
state_before: case convert_4
R : Type u_1
A : Type u_2
B : Type ?u.20732
inst✝⁶ : CommSemiring R
inst✝⁵ : StarRing R
inst✝⁴ : TopologicalSpace A
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : StarRing A
inst✝ : StarModule R A
S₁ S₂ : StarSubalgebra R A
h : S₁ ≤ S₂
hS₁ : IsClosed ↑S₁
src✝ : Embedding ↑(inclusion h) := embedding_inclusion h
x✝ : A
h' : x✝ ∈ S₁
⊢ id x✝ ∈ S₂
Theorem: Filter.limsInf_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.84212
γ : Type ?u.84215
ι : Type ?u.84218
inst✝ : CompleteLattice α
⊢ ⊤ ∈ {a | ∀ᶠ (n : α) in ⊥, a ≤ n}
Theorem: ContinuousLinearMap.map_sub
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: exact map_sub f x y
state_before: R : Type u_1
inst✝¹³ : Ring R
R₂ : Type u_2
inst✝¹² : Ring R₂
R₃ : Type ?u.721138
inst✝¹¹ : Ring R₃
M : Type u_3
inst✝¹⁰ : TopologicalSpace M
inst✝⁹ : AddCommGroup M
M₂ : Type u_4
inst✝⁸ : TopologicalSpace M₂
inst✝⁷ : AddCommGroup M₂
M₃ : Type ?u.721162
inst✝⁶ : TopologicalSpace M₃
inst✝⁵ : AddCommGroup M₃
M₄ : Type ?u.721171
inst✝⁴ : TopologicalSpace M₄
inst✝³ : AddCommGroup M₄
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
f : M →SL[σ₁₂] M₂
x y : M
⊢ ↑f (x - y) = ↑f x - ↑f y
Theorem: Set.sUnion_prod_const
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [sUnion_eq_biUnion, iUnion₂_prod_const, biUnion_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.232963
ι : Sort ?u.232966
ι' : Sort ?u.232969
ι₂ : Sort ?u.232972
κ : ι → Sort ?u.232977
κ₁ : ι → Sort ?u.232982
κ₂ : ι → Sort ?u.232987
κ' : ι' → Sort ?u.232992
C : Set (Set α)
t : Set β
⊢ ⋃₀ C ×ˢ t = ⋃₀ ((fun s => s ×ˢ t) '' C)
Theorem: Real.tendsto_sin_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: convert continuous_sin.continuousWithinAt.tendsto using 2
state_before: ⊢ Tendsto sin (𝓝[Ioi (-(π / 2))] (-(π / 2))) (𝓝 (-1))

tactic: simp
state_before: case h.e'_5.h.e'_3

⊢ -1 = sin (-(π / 2))
Theorem: Homeomorph.image_closure
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← preimage_symm, preimage_closure]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.66092
δ : Type ?u.66095
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
s : Set α
⊢ ↑h '' closure s = closure (↑h '' s)
Theorem: sigmaFinsuppEquivDfinsupp_support
File: Mathlib/Data/Finsupp/ToDfinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type ?u.69432
M : Type ?u.69435
η : ι → Type u_3
N : Type u_2
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
⊢ Dfinsupp.support (↑sigmaFinsuppEquivDfinsupp f) = splitSupport f

tactic: rw [Dfinsupp.mem_support_toFun]
state_before: case a
ι : Type u_1
R : Type ?u.69432
M : Type ?u.69435
η : ι → Type u_3
N : Type u_2
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ a✝ ∈ Dfinsupp.support (↑sigmaFinsuppEquivDfinsupp f) ↔ a✝ ∈ splitSupport f

tactic: exact (Finsupp.mem_splitSupport_iff_nonzero _ _).symm
state_before: case a
ι : Type u_1
R : Type ?u.69432
M : Type ?u.69435
η : ι → Type u_3
N : Type u_2
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ ↑(↑sigmaFinsuppEquivDfinsupp f) a✝ ≠ 0 ↔ a✝ ∈ splitSupport f
Theorem: SimplicialObject.Split.congr_f
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: rw [h]
state_before: C : Type u_1
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
S₁ S₂ : Split C
Φ₁ Φ₂ : S₁ ⟶ S₂
h : Φ₁ = Φ₂
n : ℕ
⊢ Hom.f Φ₁ n = Hom.f Φ₂ n
Theorem: Ideal.Quotient.isDomain_iff_prime
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: refine' ⟨fun H => ⟨zero_ne_one_iff.1 _, fun {x y} h => _⟩, fun h => inferInstance⟩
state_before: R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
I : Ideal R
⊢ IsDomain (R ⧸ I) ↔ IsPrime I

tactic: haveI : Nontrivial (R ⧸ I) := ⟨H.2.1⟩
state_before: case refine'_1
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
I : Ideal R
H : IsDomain (R ⧸ I)
⊢ 0 ≠ 1

tactic: exact zero_ne_one
state_before: case refine'_1
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
I : Ideal R
H : IsDomain (R ⧸ I)
this : Nontrivial (R ⧸ I)
⊢ 0 ≠ 1

tactic: simp only [← eq_zero_iff_mem, (mk I).map_mul] at h⊢
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y✝ : R
I : Ideal R
H : IsDomain (R ⧸ I)
x y : R
h : x * y ∈ I
⊢ x ∈ I ∨ y ∈ I

tactic: haveI := @IsDomain.to_noZeroDivisors (R ⧸ I) _ H
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y✝ : R
I : Ideal R
H : IsDomain (R ⧸ I)
x y : R
h : ↑(mk I) x * ↑(mk I) y = 0
⊢ ↑(mk I) x = 0 ∨ ↑(mk I) y = 0

tactic: exact eq_zero_or_eq_zero_of_mul_eq_zero h
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y✝ : R
I : Ideal R
H : IsDomain (R ⧸ I)
x y : R
h : ↑(mk I) x * ↑(mk I) y = 0
this : NoZeroDivisors (R ⧸ I)
⊢ ↑(mk I) x = 0 ∨ ↑(mk I) y = 0
Theorem: Set.sized_iUnion
File: Mathlib/Data/Finset/Slice.lean

tactic: simp_rw [Set.Sized, Set.mem_iUnion, forall_exists_index]
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort ?u.406
A B : Set (Finset α)
r : ℕ
f : ι → Set (Finset α)
⊢ Sized r (⋃ (i : ι), f i) ↔ ∀ (i : ι), Sized r (f i)

tactic: exact forall_swap
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort ?u.406
A B : Set (Finset α)
r : ℕ
f : ι → Set (Finset α)
⊢ (∀ ⦃x : Finset α⦄ (x_1 : ι), x ∈ f x_1 → card x = r) ↔ ∀ (i : ι) ⦃x : Finset α⦄, x ∈ f i → card x = r
Theorem: Real.logb_lt_logb_iff_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_lt_div_right_of_neg (log_neg b_pos b_lt_one)]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hy : 0 < y
⊢ logb b x < logb b y ↔ y < x

tactic: exact log_lt_log_iff hy hx
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hy : 0 < y
⊢ log y < log x ↔ y < x
Theorem: Finset.max'_eq_sorted_last
File: Mathlib/Data/Finset/Sort.lean

tactic: simpa using Nat.sub_lt (card_pos.mpr h) zero_lt_one
state_before: α : Type ?u.23141
β : Type ?u.23144
inst✝ : LinearOrder α
s : Finset α
h : Finset.Nonempty s
⊢ List.length (sort (fun x x_1 => x ≤ x_1) s) - 1 < List.length (sort (fun x x_1 => x ≤ x_1) s)
Theorem: IsPrimePow.pow
File: Mathlib/Algebra/IsPrimePow.lean

tactic: rw [pow_mul', hn]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p✝ : R
k✝ : ℕ
n : R
hn✝ : IsPrimePow n
k : ℕ
hk : k ≠ 0
p : R
k' : ℕ
hp : Prime p
hk' : 0 < k'
hn : p ^ k' = n
⊢ p ^ (k * k') = n ^ k
Theorem: Seminorm.ball_comp
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type ?u.894129
R' : Type ?u.894132
𝕜 : Type u_3
𝕜₂ : Type u_1
𝕜₃ : Type ?u.894141
𝕝 : Type ?u.894144
E : Type u_4
E₂ : Type u_2
E₃ : Type ?u.894153
F : Type ?u.894156
G : Type ?u.894159
ι : Type ?u.894162
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜₂ E₂
f : E →ₛₗ[σ₁₂] E₂
x : E
r : ℝ
⊢ ball (comp p f) x r = ↑f ⁻¹' ball p (↑f x) r

tactic: simp_rw [ball, mem_preimage, comp_apply, Set.mem_setOf_eq, map_sub]
state_before: case h
R : Type ?u.894129
R' : Type ?u.894132
𝕜 : Type u_3
𝕜₂ : Type u_1
𝕜₃ : Type ?u.894141
𝕝 : Type ?u.894144
E : Type u_4
E₂ : Type u_2
E₃ : Type ?u.894153
F : Type ?u.894156
G : Type ?u.894159
ι : Type ?u.894162
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜₂ E₂
f : E →ₛₗ[σ₁₂] E₂
x : E
r : ℝ
x✝ : E
⊢ x✝ ∈ ball (comp p f) x r ↔ x✝ ∈ ↑f ⁻¹' ball p (↑f x) r
Theorem: leftCoset_assoc
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [leftCoset, rightCoset, (image_comp _ _ _).symm, Function.comp, mul_assoc]
state_before: α : Type u_1
inst✝ : Semigroup α
s : Set α
a b : α
⊢ a *l (b *l s) = a * b *l s
Theorem: MeasureTheory.SimpleFunc.piecewise_compl
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [hs]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.35722
δ : Type ?u.35725
inst✝ : MeasurableSpace α
s : Set α
hs : MeasurableSet (sᶜ)
f g : α →ₛ β
⊢ ↑(piecewise (sᶜ) hs f g) = ↑(piecewise s (_ : MeasurableSet s) g f)

tactic: convert Set.piecewise_compl s f g
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.35722
δ : Type ?u.35725
inst✝ : MeasurableSpace α
s : Set α
hs : MeasurableSet (sᶜ)
f g : α →ₛ β
⊢ Set.piecewise (sᶜ) ↑f ↑g = Set.piecewise s ↑g ↑f
Theorem: ContDiffBump.support_normed_eq
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: unfold ContDiffBump.normed
state_before: E : Type u_1
X : Type ?u.1976566
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ Function.support (ContDiffBump.normed f μ) = ball c f.rOut

tactic: rw [support_div, f.support_eq, support_const f.integral_pos.ne', inter_univ]
state_before: E : Type u_1
X : Type ?u.1976566
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ (Function.support fun x => ↑f x / ∫ (x : E), ↑f x ∂μ) = ball c f.rOut
Theorem: AdjoinRoot.aeval_algHom_eq_zero
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: have h : ϕ.toRingHom.comp (of f) = algebraMap R S := RingHom.ext_iff.mpr ϕ.commutes
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
ϕ : AdjoinRoot f →ₐ[R] S
⊢ ↑(aeval (↑ϕ (root f))) f = 0

tactic: rw [aeval_def, ← h, ← RingHom.map_zero ϕ.toRingHom, ← eval₂_root f, hom_eval₂]
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
ϕ : AdjoinRoot f →ₐ[R] S
h : RingHom.comp (↑ϕ) (of f) = algebraMap R S
⊢ ↑(aeval (↑ϕ (root f))) f = 0

tactic: rfl
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
ϕ : AdjoinRoot f →ₐ[R] S
h : RingHom.comp (↑ϕ) (of f) = algebraMap R S
⊢ eval₂ (RingHom.comp (↑ϕ) (of f)) (↑ϕ (root f)) f = eval₂ (RingHom.comp (↑ϕ) (of f)) (↑↑ϕ (root f)) f
Theorem: Finset.insert_union_distrib
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [insert_union, union_insert, insert_idem]
state_before: α : Type u_1
β : Type ?u.150533
γ : Type ?u.150536
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ insert a (s ∪ t) = insert a s ∪ insert a t
Theorem: Rat.uniformContinuous_abs
File: Mathlib/Topology/Instances/Rat.lean

tactic: simpa [Rat.dist_eq] using abs_abs_sub_abs_le_abs_sub _ _
state_before: ε : ℝ
ε0 : ε > 0
a✝ b✝ : ℚ
h : dist a✝ b✝ < ε
⊢ dist (abs a✝) (abs b✝) ≤ dist a✝ b✝
Theorem: sdiff_triangle
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_le_iff, sup_left_comm, ← sdiff_le_iff]
state_before: ι : Type ?u.141596
α : Type u_1
β : Type ?u.141602
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a \ c ≤ a \ b ⊔ b \ c

tactic: exact sdiff_sdiff_le.trans le_sup_sdiff
state_before: ι : Type ?u.141596
α : Type u_1
β : Type ?u.141602
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a \ (a \ b) ≤ c ⊔ b \ c
Theorem: List.zipRight'_nil_left
File: Mathlib/Data/List/Basic.lean

tactic: cases bs <;> rfl
state_before: ι : Type ?u.464373
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ zipRight' [] bs = (map (fun b => (none, b)) bs, [])
Theorem: card_commutator_closureCommutatorRepresentatives
File: Mathlib/GroupTheory/Abelianization.lean

tactic: rw [commutator_eq_closure G, ← image_commutatorSet_closureCommutatorRepresentatives, ←
  MonoidHom.map_closure, ← commutator_eq_closure]
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card { x // x ∈ _root_.commutator { x // x ∈ closureCommutatorRepresentatives G } } =
    Nat.card { x // x ∈ _root_.commutator G }

tactic: exact Nat.card_congr (Equiv.Set.image _ _ (subtype_injective _))
state_before: G : Type u
inst✝ : Group G
⊢ Nat.card { x // x ∈ _root_.commutator { x // x ∈ closureCommutatorRepresentatives G } } =
    Nat.card
      { x //
        x ∈
          map (Subgroup.subtype (closureCommutatorRepresentatives G))
            (_root_.commutator { x // x ∈ closureCommutatorRepresentatives G }) }
Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap.congr_point
File: Mathlib/AlgebraicGeometry/Stalks.lean

tactic: rw [h]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
x x' : ↑↑X
h : x = x'
⊢ stalk X x = stalk X x'

tactic: rw [h]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
x x' : ↑↑X
h : x = x'
⊢ stalk Y ((CategoryTheory.forget TopCat).map α.base x) = stalk Y ((CategoryTheory.forget TopCat).map α.base x')

tactic: rw [stalkMap.congr α α rfl x x' h]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α : X ⟶ Y
x x' : ↑↑X
h : x = x'
⊢ stalkMap α x ≫ eqToHom (_ : stalk X x = stalk X x') =
    eqToHom
        (_ :
          stalk Y ((CategoryTheory.forget TopCat).map α.base x) =
            stalk Y ((CategoryTheory.forget TopCat).map α.base x')) ≫
      stalkMap α x'
Theorem: norm_iteratedFDeriv_mul_le
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type ?u.4170268
inst✝³ : NormedAddCommGroup X
inst✝² : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
A : Type u_2
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
f g : E → A
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => f y * g y) x‖ ≤
    ∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖

tactic: exact norm_iteratedFDerivWithin_mul_le
  hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ (mem_univ x) hn
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹¹ : NormedAddCommGroup D
inst✝¹⁰ : NormedSpace 𝕜 D
E : Type uE
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type uF
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
G : Type uG
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
X : Type ?u.4170268
inst✝³ : NormedAddCommGroup X
inst✝² : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
A : Type u_2
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
f g : E → A
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : E
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => f y * g y) univ x‖ ≤
    ∑ x_1 in Finset.range (n + 1),
      ↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
Theorem: Finset.prod_nonneg_of_card_nonpos_even
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: split_ifs with hx
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (card (filter (fun x => f x ≤ 0) s))
x : α
x✝ : x ∈ s
⊢ 0 ≤ (if f x ≤ 0 then -1 else 1) * f x

tactic: simp at hx ⊢
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (card (filter (fun x => f x ≤ 0) s))
x : α
x✝ : x ∈ s
hx : ¬f x ≤ 0
⊢ 0 ≤ 1 * f x

tactic: exact le_of_lt hx
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (card (filter (fun x => f x ≤ 0) s))
x : α
x✝ : x ∈ s
hx : 0 < f x
⊢ 0 ≤ f x

tactic: simp [hx]
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (card (filter (fun x => f x ≤ 0) s))
x : α
x✝ : x ∈ s
hx : f x ≤ 0
⊢ 0 ≤ -1 * f x

tactic: rw [Finset.prod_mul_distrib, Finset.prod_ite, Finset.prod_const_one, mul_one,
  Finset.prod_const, neg_one_pow_eq_pow_mod_two, Nat.even_iff.1 h0, pow_zero, one_mul]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedCommRing β
f : α → β
inst✝ : DecidablePred fun x => f x ≤ 0
s : Finset α
h0 : Even (card (filter (fun x => f x ≤ 0) s))
⊢ ∏ x in s, (if f x ≤ 0 then -1 else 1) * f x = ∏ x in s, f x
Theorem: Fin.Ioi_eq_finset_subtype
File: Mathlib/Data/Fin/Interval.lean

tactic: ext
state_before: n : ℕ
a b : Fin n
⊢ Ioi a = Finset.fin n (Ioc (↑a) n)

tactic: simp
state_before: case a
n : ℕ
a b a✝ : Fin n
⊢ a✝ ∈ Ioi a ↔ a✝ ∈ Finset.fin n (Ioc (↑a) n)
Theorem: Submodule.map_unop_mul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [← map_comp, map_op_mul, ← map_comp, ← map_comp, LinearEquiv.comp_coe,
  LinearEquiv.symm_trans_self, LinearEquiv.refl_toLinearMap, map_id, map_id, map_id]
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
M N : Submodule R Aᵐᵒᵖ
this : Function.Injective ↑↑(opLinearEquiv R)
⊢ map (↑(opLinearEquiv R)) (map (↑(LinearEquiv.symm (opLinearEquiv R))) (M * N)) =
    map (↑(opLinearEquiv R))
      (map (↑(LinearEquiv.symm (opLinearEquiv R))) N * map (↑(LinearEquiv.symm (opLinearEquiv R))) M)
Theorem: Prod.ωSup_zip
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: apply eq_of_forall_ge_iff
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.22086
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
⊢ ωSup (Chain.zip c₀ c₁) = (ωSup c₀, ωSup c₁)

tactic: rintro ⟨z₁, z₂⟩
state_before: case H
α : Type u_1
β : Type u_2
γ : Type ?u.22086
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
⊢ ∀ (c : α × β), ωSup (Chain.zip c₀ c₁) ≤ c ↔ (ωSup c₀, ωSup c₁) ≤ c

tactic: simp [ωSup_le_iff, forall_and]
state_before: case H.mk
α : Type u_1
β : Type u_2
γ : Type ?u.22086
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
z₁ : α
z₂ : β
⊢ ωSup (Chain.zip c₀ c₁) ≤ (z₁, z₂) ↔ (ωSup c₀, ωSup c₁) ≤ (z₁, z₂)
Theorem: toIcoMod_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoMod_add_right', add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (p + a) b = p + toIcoMod hp a b
Theorem: nhds_nhds_eq_uniformity_uniformity_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [nhds_eq_uniformity', nhds_eq_uniformity, prod_lift'_lift']
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78279
inst✝ : UniformSpace α
a b : α
⊢ 𝓝 a ×ˢ 𝓝 b = Filter.lift (𝓤 α) fun s => Filter.lift' (𝓤 α) fun t => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ t}

tactic: exacts [rfl, monotone_preimage, monotone_preimage]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78279
inst✝ : UniformSpace α
a b : α
⊢ (Filter.lift (𝓤 α) fun s => Filter.lift' (𝓤 α) fun t => {y | (y, a) ∈ s} ×ˢ ball b t) =
    Filter.lift (𝓤 α) fun s => Filter.lift' (𝓤 α) fun t => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ t}

case hg₁
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78279
inst✝ : UniformSpace α
a b : α
⊢ Monotone fun s => {y | (y, a) ∈ s}

case hg₂
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78279
inst✝ : UniformSpace α
a b : α
⊢ Monotone (ball b)
Theorem: IsPreconnected.subset_clopen
File: Mathlib/Topology/Connected.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Type ?u.31419
π : ι → Type ?u.31424
inst✝ : TopologicalSpace α
s✝ t✝ u v s t : Set α
hs : IsPreconnected s
ht : IsClopen t
hne : Set.Nonempty (s ∩ t)
⊢ s ⊆ t ∪ tᶜ
Theorem: Real.Angle.toReal_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: constructor <;> linarith [pi_pos]
state_before: ⊢ -π < -π / 2 ∧ -π / 2 ≤ π
Theorem: Finset.Ico_filter_le_left
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext x
state_before: ι : Type ?u.109806
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
⊢ filter (fun x => x ≤ a) (Ico a b) = {a}

tactic: rw [mem_filter, mem_Ico, mem_singleton, and_right_comm, ← le_antisymm_iff, eq_comm]
state_before: case a
ι : Type ?u.109806
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x ∈ filter (fun x => x ≤ a) (Ico a b) ↔ x ∈ {a}

tactic: exact and_iff_left_of_imp fun h => h.le.trans_lt hab
state_before: case a
ι : Type ?u.109806
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x = a ∧ x < b ↔ x = a