tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.TaggedPrepartition.IsHenstock.disjUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: refine' fun J hJ => (Finset.mem_union.1 hJ).elim (fun hJ => _) fun hJ => _
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : IsHenstock π₁
h₂ : IsHenstock π₂
h : Disjoint (iUnion π₁) (iUnion π₂)
⊢ IsHenstock (TaggedPrepartition.disjUnion π₁ π₂ h)

tactic: rw [disjUnion_tag_of_mem_left _ hJ]
state_before: case refine'_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : IsHenstock π₁
h₂ : IsHenstock π₂
h : Disjoint (iUnion π₁) (iUnion π₂)
J : Box ι
hJ✝ : J ∈ TaggedPrepartition.disjUnion π₁ π₂ h
hJ : J ∈ π₁.boxes
⊢ tag (TaggedPrepartition.disjUnion π₁ π₂ h) J ∈ ↑Box.Icc J

tactic: exact h₁ _ hJ
state_before: case refine'_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : IsHenstock π₁
h₂ : IsHenstock π₂
h : Disjoint (iUnion π₁) (iUnion π₂)
J : Box ι
hJ✝ : J ∈ TaggedPrepartition.disjUnion π₁ π₂ h
hJ : J ∈ π₁.boxes
⊢ tag π₁ J ∈ ↑Box.Icc J

tactic: rw [disjUnion_tag_of_mem_right _ hJ]
state_before: case refine'_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : IsHenstock π₁
h₂ : IsHenstock π₂
h : Disjoint (iUnion π₁) (iUnion π₂)
J : Box ι
hJ✝ : J ∈ TaggedPrepartition.disjUnion π₁ π₂ h
hJ : J ∈ π₂.boxes
⊢ tag (TaggedPrepartition.disjUnion π₁ π₂ h) J ∈ ↑Box.Icc J

tactic: exact h₂ _ hJ
state_before: case refine'_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : IsHenstock π₁
h₂ : IsHenstock π₂
h : Disjoint (iUnion π₁) (iUnion π₂)
J : Box ι
hJ✝ : J ∈ TaggedPrepartition.disjUnion π₁ π₂ h
hJ : J ∈ π₂.boxes
⊢ tag π₂ J ∈ ↑Box.Icc J
Theorem: Nat.one_lt_bit1
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: contradiction
state_before: h : 0 ≠ 0
⊢ 1 < bit1 0

tactic: rw [Nat.bit1_succ_eq]
state_before: n : ℕ
x✝ : succ n ≠ 0
⊢ 1 < bit1 (succ n)

tactic: apply succ_lt_succ
state_before: n : ℕ
x✝ : succ n ≠ 0
⊢ 1 < succ (succ (bit1 n))

tactic: apply zero_lt_succ
state_before: case a
n : ℕ
x✝ : succ n ≠ 0
⊢ 0 < bit1 n + 1
Theorem: BoxIntegral.Prepartition.biUnion_congr
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: subst π₂
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h : π₁ = π₂
hi : ∀ (J : Box ι), J ∈ π₁ → πi₁ J = πi₂ J
⊢ biUnion π₁ πi₁ = biUnion π₂ πi₂

tactic: ext J
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hi : ∀ (J : Box ι), J ∈ π₁ → πi₁ J = πi₂ J
⊢ biUnion π₁ πi₁ = biUnion π₁ πi₂

tactic: simp only [mem_biUnion]
state_before: case h
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hi : ∀ (J : Box ι), J ∈ π₁ → πi₁ J = πi₂ J
J : Box ι
⊢ J ∈ biUnion π₁ πi₁ ↔ J ∈ biUnion π₁ πi₂

tactic: constructor <;> exact fun ⟨J', h₁, h₂⟩ => ⟨J', h₁, hi J' h₁ ▸ h₂⟩
state_before: case h
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hi : ∀ (J : Box ι), J ∈ π₁ → πi₁ J = πi₂ J
J : Box ι
⊢ (∃ J', J' ∈ π₁ ∧ J ∈ πi₁ J') ↔ ∃ J', J' ∈ π₁ ∧ J ∈ πi₂ J'
Theorem: IsUnit.mul_div_mul_left
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [mul_comm c, mul_comm c, h.mul_div_mul_right]
state_before: F : Type ?u.63975
G : Type ?u.63978
α : Type u_1
M : Type ?u.63984
N : Type ?u.63987
inst✝ : DivisionCommMonoid α
a✝ b✝ c d : α
h : IsUnit c
a b : α
⊢ c * a / (c * b) = a / b
Theorem: Prod.noncompactSpace_iff
File: Mathlib/Topology/SubsetProperties.lean

tactic: simp [← Filter.cocompact_neBot_iff, ← Filter.coprod_cocompact, Filter.coprod_neBot_iff]
state_before: α : Type u
β : Type v
ι : Type ?u.103613
π : ι → Type ?u.103618
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ NoncompactSpace (α × β) ↔ NoncompactSpace α ∧ Nonempty β ∨ Nonempty α ∧ NoncompactSpace β
Theorem: FreeProduct.NeWord.toList_getLast?
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: rw [← Option.mem_def]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ List.getLast? (toList w) = some { fst := j, snd := last w }

tactic: induction w
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ { fst := j, snd := last w } ∈ List.getLast? (toList w)

tactic: rw [Option.mem_def]
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ { fst := i✝, snd := last (singleton x✝ a✝) } ∈ List.getLast? (toList (singleton x✝ a✝))

tactic: rfl
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ List.getLast? (toList (singleton x✝ a✝)) = some { fst := i✝, snd := last (singleton x✝ a✝) }

tactic: exact List.getLast?_append (by assumption)
state_before: case append
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : { fst := j✝, snd := last _w₁✝ } ∈ List.getLast? (toList _w₁✝)
_w₂_ih✝ : { fst := l✝, snd := last _w₂✝ } ∈ List.getLast? (toList _w₂✝)
⊢ { fst := l✝, snd := last (append _w₁✝ _hne✝ _w₂✝) } ∈ List.getLast? (toList (append _w₁✝ _hne✝ _w₂✝))

tactic: assumption
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490904
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : { fst := j✝, snd := last _w₁✝ } ∈ List.getLast? (toList _w₁✝)
_w₂_ih✝ : { fst := l✝, snd := last _w₂✝ } ∈ List.getLast? (toList _w₂✝)
⊢ { fst := l✝, snd := last (append _w₁✝ _hne✝ _w₂✝) } ∈ List.getLast? (toList _w₂✝)
Theorem: Prod.map_bijective
File: Mathlib/Data/Prod/Basic.lean

tactic: haveI := Nonempty.map f ‹_›
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
⊢ Bijective (map f g) ↔ Bijective f ∧ Bijective g

tactic: haveI := Nonempty.map g ‹_›
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
this : Nonempty γ
⊢ Bijective (map f g) ↔ Bijective f ∧ Bijective g

tactic: exact (map_injective.and map_surjective).trans (and_and_and_comm)
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
this✝ : Nonempty γ
this : Nonempty δ
⊢ Bijective (map f g) ↔ Bijective f ∧ Bijective g
Theorem: MeasureTheory.integral_congr_ae
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.943889
𝕜 : Type ?u.943892
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
h : f =ᵐ[μ] g
⊢ (∫ (a : α), f a ∂μ) = ∫ (a : α), g a ∂μ

tactic: exact setToFun_congr_ae (dominatedFinMeasAdditive_weightedSMul μ) h
state_before: α : Type u_1
E : Type u_2
F : Type ?u.943889
𝕜 : Type ?u.943892
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
h : f =ᵐ[μ] g
⊢ (if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0) =
    if hf : Integrable fun a => g a then ↑L1.integralCLM (Integrable.toL1 (fun a => g a) hf) else 0
Theorem: Nat.gcd_add_mul_right_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [gcd_comm, gcd_add_mul_right_right, gcd_comm]
state_before: m n k : ℕ
⊢ gcd (m + k * n) n = gcd m n
Theorem: continuousWithinAt_compl_self
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [compl_eq_univ_diff, continuousWithinAt_diff_self, continuousWithinAt_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.326677
δ : Type ?u.326680
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
a : α
⊢ ContinuousWithinAt f ({a}ᶜ) a ↔ ContinuousAt f a
Theorem: MvPolynomial.map_mvPolynomial_eq_eval₂
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: cases nonempty_fintype σ
state_before: R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
⊢ ↑ϕ p = eval₂ (RingHom.comp ϕ C) (fun s => ↑ϕ (X s)) p

tactic: refine' Trans.trans (congr_arg ϕ (MvPolynomial.as_sum p)) _
state_before: case intro
R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
val✝ : Fintype σ
⊢ ↑ϕ p = eval₂ (RingHom.comp ϕ C) (fun s => ↑ϕ (X s)) p

tactic: rw [MvPolynomial.eval₂_eq', ϕ.map_sum]
state_before: case intro
R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
val✝ : Fintype σ
⊢ ↑ϕ (∑ v in support p, ↑(monomial v) (coeff v p)) = eval₂ (RingHom.comp ϕ C) (fun s => ↑ϕ (X s)) p

tactic: congr
state_before: case intro
R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
val✝ : Fintype σ
⊢ ∑ x in support p, ↑ϕ (↑(monomial x) (coeff x p)) =
    ∑ d in support p, ↑(RingHom.comp ϕ C) (coeff d p) * ∏ i : σ, ↑ϕ (X i) ^ ↑d i

tactic: ext
state_before: case intro.e_f
R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
val✝ : Fintype σ
⊢ (fun x => ↑ϕ (↑(monomial x) (coeff x p))) = fun d => ↑(RingHom.comp ϕ C) (coeff d p) * ∏ i : σ, ↑ϕ (X i) ^ ↑d i

tactic: simp only [monomial_eq, ϕ.map_pow, ϕ.map_prod, ϕ.comp_apply, ϕ.map_mul, Finsupp.prod_pow]
state_before: case intro.e_f.h
R : Type u
S✝ : Type ?u.883146
σ : Type v
M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S✝
inst✝³ : AddCommGroup M
inst✝² : Module R M
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Finite σ
ϕ : MvPolynomial σ R →+* S
p : MvPolynomial σ R
val✝ : Fintype σ
x✝ : σ →₀ ℕ
⊢ ↑ϕ (↑(monomial x✝) (coeff x✝ p)) = ↑(RingHom.comp ϕ C) (coeff x✝ p) * ∏ i : σ, ↑ϕ (X i) ^ ↑x✝ i
Theorem: mem_span_gramSchmidt
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: rw [gramSchmidt_def' 𝕜 f i]
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ f i ∈ span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)

tactic: simp_rw [orthogonalProjection_singleton]
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i + ∑ i_1 in Finset.Iio i, ↑(↑(orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i_1})) (f i)) ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)

tactic: exact Submodule.add_mem _ (subset_span <| mem_image_of_mem _ hij)
  (Submodule.sum_mem _ fun k hk => smul_mem (span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)) _ <|
    subset_span <| mem_image_of_mem (gramSchmidt 𝕜 f) <| (Finset.mem_Iio.1 hk).le.trans hij)
state_before: 𝕜 : Type u_3
E : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_1
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
i j : ι
hij : i ≤ j
⊢ gramSchmidt 𝕜 f i +
      ∑ x in Finset.Iio i, (inner (gramSchmidt 𝕜 f x) (f i) / ↑(‖gramSchmidt 𝕜 f x‖ ^ 2)) • gramSchmidt 𝕜 f x ∈
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic j)
Theorem: ContinuousLinearMap.strongUniformity.uniformAddGroup
File: Mathlib/Topology/Algebra/Module/StrongTopology.lean

tactic: letI : UniformSpace (E →SL[σ] F) := strongUniformity σ F 𝔖
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_4
inst✝¹³ : NormedField 𝕜₁
inst✝¹² : NormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
E : Type u_2
E' : Type ?u.30258
F : Type u_1
F' : Type ?u.30264
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : Module 𝕜₁ E
inst✝⁹ : AddCommGroup E'
inst✝⁸ : Module ℝ E'
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module 𝕜₂ F
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module ℝ F'
inst✝³ : TopologicalSpace E
inst✝² : TopologicalSpace E'
inst✝¹ : UniformSpace F
inst✝ : UniformAddGroup F
𝔖 : Set (Set E)
⊢ UniformAddGroup (E →SL[σ] F)

tactic: rw [strongUniformity, UniformSpace.replaceTopology_eq]
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_4
inst✝¹³ : NormedField 𝕜₁
inst✝¹² : NormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
E : Type u_2
E' : Type ?u.30258
F : Type u_1
F' : Type ?u.30264
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : Module 𝕜₁ E
inst✝⁹ : AddCommGroup E'
inst✝⁸ : Module ℝ E'
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module 𝕜₂ F
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module ℝ F'
inst✝³ : TopologicalSpace E
inst✝² : TopologicalSpace E'
inst✝¹ : UniformSpace F
inst✝ : UniformAddGroup F
𝔖 : Set (Set E)
this : UniformSpace (E →SL[σ] F) := strongUniformity σ F 𝔖
⊢ UniformAddGroup (E →SL[σ] F)

tactic: let φ : (E →SL[σ] F) →+ E →ᵤ[𝔖] F :=
  ⟨⟨(FunLike.coe : (E →SL[σ] F) → E →ᵤ[𝔖] F), rfl⟩, fun _ _ => rfl⟩
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_4
inst✝¹³ : NormedField 𝕜₁
inst✝¹² : NormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
E : Type u_2
E' : Type ?u.30258
F : Type u_1
F' : Type ?u.30264
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : Module 𝕜₁ E
inst✝⁹ : AddCommGroup E'
inst✝⁸ : Module ℝ E'
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module 𝕜₂ F
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module ℝ F'
inst✝³ : TopologicalSpace E
inst✝² : TopologicalSpace E'
inst✝¹ : UniformSpace F
inst✝ : UniformAddGroup F
𝔖 : Set (Set E)
this : UniformSpace (E →SL[σ] F) := strongUniformity σ F 𝔖
⊢ UniformAddGroup (E →SL[σ] F)

tactic: exact uniformAddGroup_comap φ
state_before: 𝕜₁ : Type u_3
𝕜₂ : Type u_4
inst✝¹³ : NormedField 𝕜₁
inst✝¹² : NormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
E : Type u_2
E' : Type ?u.30258
F : Type u_1
F' : Type ?u.30264
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : Module 𝕜₁ E
inst✝⁹ : AddCommGroup E'
inst✝⁸ : Module ℝ E'
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module 𝕜₂ F
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module ℝ F'
inst✝³ : TopologicalSpace E
inst✝² : TopologicalSpace E'
inst✝¹ : UniformSpace F
inst✝ : UniformAddGroup F
𝔖 : Set (Set E)
this : UniformSpace (E →SL[σ] F) := strongUniformity σ F 𝔖
φ : (E →SL[σ] F) →+ E →ᵤ[𝔖] F :=
  { toZeroHom := { toFun := FunLike.coe, map_zero' := (_ : ↑0 = ↑0) },
    map_add' :=
      (_ :
        ∀ (x x_1 : E →SL[σ] F),
          ZeroHom.toFun { toFun := FunLike.coe, map_zero' := (_ : ↑0 = ↑0) } (x + x_1) =
            ZeroHom.toFun { toFun := FunLike.coe, map_zero' := (_ : ↑0 = ↑0) } (x + x_1)) }
⊢ UniformAddGroup (E →SL[σ] F)
Theorem: Acc.ndrec_eq_ndrecC
File: Std/WF.lean

tactic: funext α r motive intro a t
state_before: ⊢ @ndrec = @Acc.ndrecC

tactic: rw [Acc.ndrec, rec_eq_recC, Acc.ndrecC]
state_before: case h.h.h.h.h.h
α : Sort u_1
r : α → α → Prop
motive : α → Sort u_2
intro : (x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → motive y) → motive x
a : α
t : Acc r a
⊢ ndrec intro t = Acc.ndrecC intro t
Theorem: dite_dite_distrib_left
File: Mathlib/Logic/Lemmas.lean

tactic: split_ifs <;> rfl
state_before: α : Sort u_1
p q r : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
a✝ b✝ c✝ : α
a : p → α
b : ¬p → q → α
c : ¬p → ¬q → α
⊢ (dite p a fun hp => dite q (b hp) (c hp)) = if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq
Theorem: CategoryTheory.Limits.inl_inl_pushoutLeftPushoutInrIso_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← Category.assoc, ← Iso.eq_comp_inv, inl_pushoutLeftPushoutInrIso_inv]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
g' : Z ⟶ W
inst✝² : HasPushout f g
inst✝¹ : HasPushout pushout.inr g'
inst✝ : HasPushout f (g ≫ g')
⊢ pushout.inl ≫ pushout.inl ≫ (pushoutLeftPushoutInrIso f g g').hom = pushout.inl
Theorem: Polynomial.card_roots_le_derivative
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simp only [Finset.sum_add_distrib, Finset.card_eq_sum_ones, count_roots]
state_before: p : ℝ[X]
⊢ ∑ x in Multiset.toFinset (roots p), (Multiset.count x (roots p) - 1 + 1) =
    ∑ x in Multiset.toFinset (roots p), (rootMultiplicity x p - 1) + Finset.card (Multiset.toFinset (roots p))

tactic: simp only [← count_roots]
state_before: p : ℝ[X]
⊢ ∑ x in Multiset.toFinset (roots p), rootMultiplicity x (↑derivative p) +
      (Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1) ≤
    ∑ x in Multiset.toFinset (roots p), Multiset.count x (roots (↑derivative p)) +
      (∑ x in Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p),
          Multiset.count x (roots (↑derivative p)) +
        1)

tactic: refine' add_le_add_left (add_le_add_right ((Finset.card_eq_sum_ones _).trans_le _) _) _
state_before: p : ℝ[X]
⊢ ∑ x in Multiset.toFinset (roots p), Multiset.count x (roots (↑derivative p)) +
      (Finset.card (Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)) + 1) ≤
    ∑ x in Multiset.toFinset (roots p), Multiset.count x (roots (↑derivative p)) +
      (∑ x in Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p),
          Multiset.count x (roots (↑derivative p)) +
        1)

tactic: refine' Finset.sum_le_sum fun x hx => Nat.succ_le_iff.2 <| _
state_before: p : ℝ[X]
⊢ ∑ x in Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p), 1 ≤
    ∑ x in Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p),
      Multiset.count x (roots (↑derivative p))

tactic: rw [Multiset.count_pos, ← Multiset.mem_toFinset]
state_before: p : ℝ[X]
x : ℝ
hx : x ∈ Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)
⊢ 0 < Multiset.count x (roots (↑derivative p))

tactic: exact (Finset.mem_sdiff.1 hx).1
state_before: p : ℝ[X]
x : ℝ
hx : x ∈ Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p)
⊢ x ∈ Multiset.toFinset (roots (↑derivative p))

tactic: rw [← add_assoc, ← Finset.sum_union Finset.disjoint_sdiff, Finset.union_sdiff_self_eq_union, ←
  Multiset.toFinset_sum_count_eq, ← Finset.sum_subset (Finset.subset_union_right _ _)]
state_before: p : ℝ[X]
⊢ ∑ x in Multiset.toFinset (roots p), Multiset.count x (roots (↑derivative p)) +
      (∑ x in Multiset.toFinset (roots (↑derivative p)) \ Multiset.toFinset (roots p),
          Multiset.count x (roots (↑derivative p)) +
        1) =
    ↑Multiset.card (roots (↑derivative p)) + 1

tactic: intro x _ hx₂
state_before: p : ℝ[X]
⊢ ∀ (x : ℝ),
    x ∈ Multiset.toFinset (roots p) ∪ Multiset.toFinset (roots (↑derivative p)) →
      ¬x ∈ Multiset.toFinset (roots (↑derivative p)) → Multiset.count x (roots (↑derivative p)) = 0

tactic: simpa only [Multiset.mem_toFinset, Multiset.count_eq_zero] using hx₂
state_before: p : ℝ[X]
x : ℝ
a✝ : x ∈ Multiset.toFinset (roots p) ∪ Multiset.toFinset (roots (↑derivative p))
hx₂ : ¬x ∈ Multiset.toFinset (roots (↑derivative p))
⊢ Multiset.count x (roots (↑derivative p)) = 0
Theorem: Units.divp_sub_divp_same
File: Mathlib/Algebra/Ring/Units.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, neg_divp, divp_add_divp_same]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a /ₚ u - b /ₚ u = (a - b) /ₚ u
Theorem: NormedAddGroupHom.comp_zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type ?u.476976
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : NormedAddGroupHom V₂ V₃
⊢ NormedAddGroupHom.comp f 0 = 0

tactic: exact map_zero f
state_before: case H
V : Type ?u.476976
V₁ : Type u_3
V₂ : Type u_1
V₃ : Type u_2
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ ↑(NormedAddGroupHom.comp f 0) x✝ = ↑0 x✝
Theorem: Module.End_isUnit_inv_apply_apply_of_isUnit
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: simp
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : End R M
h : IsUnit f
x : M
⊢ ↑((IsUnit.unit h).inv * f) x = x
Theorem: MeasureTheory.NullMeasurableSet.toMeasurable_ae_eq
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [toMeasurable_def, dif_pos]
state_before: ι : Type ?u.6547
α : Type u_1
β : Type ?u.6553
γ : Type ?u.6556
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ toMeasurable μ s =ᵐ[μ] s

tactic: exact (exists_measurable_superset_ae_eq h).choose_spec.snd.2
state_before: ι : Type ?u.6547
α : Type u_1
β : Type ?u.6553
γ : Type ?u.6556
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ Exists.choose ?hc =ᵐ[μ] s

case hc
ι : Type ?u.6547
α : Type u_1
β : Type ?u.6553
γ : Type ?u.6556
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
Theorem: MeasureTheory.Measure.dirac_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine' prod_eq fun s t hs ht => _
state_before: α : Type u_1
α' : Type ?u.4491225
β : Type u_2
β' : Type ?u.4491231
γ : Type ?u.4491234
E : Type ?u.4491237
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
x : α
⊢ Measure.prod (dirac x) ν = map (Prod.mk x) ν

tactic: simp_rw [map_apply measurable_prod_mk_left (hs.prod ht), mk_preimage_prod_right_eq_if, measure_if,
  dirac_apply' _ hs, ← indicator_mul_left _ _ fun _ => ν t, Pi.one_apply, one_mul]
state_before: α : Type u_1
α' : Type ?u.4491225
β : Type u_2
β' : Type ?u.4491231
γ : Type ?u.4491234
E : Type ?u.4491237
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
x : α
s : Set α
t : Set β
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(map (Prod.mk x) ν) (s ×ˢ t) = ↑↑(dirac x) s * ↑↑ν t
Theorem: Nat.le_sqrt'
File: Mathlib/Data/Nat/Sqrt.lean

tactic: simpa only [pow_two] using le_sqrt
state_before: m n : ℕ
⊢ m ≤ sqrt n ↔ m ^ 2 ≤ n