tasksource/leandojo huggingface dataset:
Theorem: ContinuousMap.sup_eq
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

tactic: simpa [mul_add] using @max_eq_half_add_add_abs_sub _ _ (f x) (g x)
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : LinearOrderedField β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : TopologicalRing β
f g : C(α, β)
x : α
⊢ ↑(f ⊔ g) x = ↑(2⁻¹ • (f + g + Abs.abs (f - g))) x
Theorem: Finset.iSup_insert
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [insert_eq]
state_before: F : Type ?u.449532
α : Type u_1
β : Type u_2
γ : Type ?u.449541
ι : Type ?u.449544
κ : Type ?u.449547
inst✝¹ : CompleteLattice β
inst✝ : DecidableEq α
a : α
s : Finset α
t : α → β
⊢ (⨆ (x : α) (_ : x ∈ insert a s), t x) = t a ⊔ ⨆ (x : α) (_ : x ∈ s), t x

tactic: simp only [iSup_union, Finset.iSup_singleton]
state_before: F : Type ?u.449532
α : Type u_1
β : Type u_2
γ : Type ?u.449541
ι : Type ?u.449544
κ : Type ?u.449547
inst✝¹ : CompleteLattice β
inst✝ : DecidableEq α
a : α
s : Finset α
t : α → β
⊢ (⨆ (x : α) (_ : x ∈ {a} ∪ s), t x) = t a ⊔ ⨆ (x : α) (_ : x ∈ s), t x
Theorem: BilinForm.mem_isPairSelfAdjointSubmodule
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rfl
state_before: R : Type ?u.1132945
M : Type ?u.1132948
inst✝²⁴ : Semiring R
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
R₁ : Type ?u.1132984
M₁ : Type ?u.1132987
inst✝²¹ : Ring R₁
inst✝²⁰ : AddCommGroup M₁
inst✝¹⁹ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁸ : CommSemiring R₂
inst✝¹⁷ : AddCommMonoid M₂
inst✝¹⁶ : Module R₂ M₂
R₃ : Type ?u.1133786
M₃ : Type ?u.1133789
inst✝¹⁵ : CommRing R₃
inst✝¹⁴ : AddCommGroup M₃
inst✝¹³ : Module R₃ M₃
V : Type ?u.1134377
K : Type ?u.1134380
inst✝¹² : Field K
inst✝¹¹ : AddCommGroup V
inst✝¹⁰ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1135594
M₂'' : Type ?u.1135597
inst✝⁹ : AddCommMonoid M₂'
inst✝⁸ : AddCommMonoid M₂''
inst✝⁷ : Module R₂ M₂'
inst✝⁶ : Module R₂ M₂''
F : BilinForm R M
M' : Type ?u.1135908
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
B' : BilinForm R M'
f✝ f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
M₁' : Type ?u.1136345
inst✝³ : AddCommGroup M₁'
inst✝² : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
B₂' : BilinForm R₂ M₂'
f₂ f₂' : M₂ →ₗ[R₂] M₂'
g₂ g₂' : M₂' →ₗ[R₂] M₂
M'' : Type ?u.1138824
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
B'' : BilinForm R M''
F₂ : BilinForm R₂ M₂
f : Module.End R₂ M₂
⊢ f ∈ isPairSelfAdjointSubmodule B₂ F₂ ↔ IsPairSelfAdjoint B₂ F₂ f
Theorem: SimplicialObject.Splitting.decomposition_id
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: apply s.hom_ext'
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
⊢ 𝟙 (X.obj Δ) = ∑ A : IndexSet Δ, πSummand s A ≫ ιSummand s A

tactic: intro A
state_before: case h
C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
⊢ ∀ (A : IndexSet Δ), ιSummand s A ≫ 𝟙 (X.obj Δ) = ιSummand s A ≫ ∑ A : IndexSet Δ, πSummand s A ≫ ιSummand s A

tactic: rw [comp_id, comp_sum, Finset.sum_eq_single A, ι_πSummand_eq_id_assoc]
state_before: case h
C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιSummand s A ≫ 𝟙 (X.obj Δ) = ιSummand s A ≫ ∑ A : IndexSet Δ, πSummand s A ≫ ιSummand s A

tactic: intro B _ h₂
state_before: case h.h₀
C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ∀ (b : IndexSet Δ), b ∈ Finset.univ → b ≠ A → ιSummand s A ≫ πSummand s b ≫ ιSummand s b = 0

tactic: rw [s.ι_πSummand_eq_zero_assoc _ _ h₂, zero_comp]
state_before: case h.h₀
C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
a✝ : B ∈ Finset.univ
h₂ : B ≠ A
⊢ ιSummand s A ≫ πSummand s B ≫ ιSummand s B = 0

tactic: simp only [Finset.mem_univ, not_true, IsEmpty.forall_iff]
state_before: case h.h₁
C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ¬A ∈ Finset.univ → ιSummand s A ≫ πSummand s A ≫ ιSummand s A = 0
Theorem: Set.prod_eq_empty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.79454
δ : Type ?u.79457
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
Theorem: Commute.inv_mul_cancel_assoc
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [← mul_assoc, h.inv_mul_cancel]
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a⁻¹ * (b * a) = b
Theorem: IntermediateField.minpoly_eq
File: Mathlib/FieldTheory/IntermediateField.lean

tactic: by_cases hx : IsIntegral K x
state_before: K : Type u_2
L : Type u_1
L' : Type ?u.315453
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S : IntermediateField K L
x : { x // x ∈ S }
⊢ minpoly K x = minpoly K ↑x

tactic: exact minpoly.eq_of_algebraMap_eq (algebraMap S L).injective hx rfl
state_before: case pos
K : Type u_2
L : Type u_1
L' : Type ?u.315453
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S : IntermediateField K L
x : { x // x ∈ S }
hx : IsIntegral K x
⊢ minpoly K x = minpoly K ↑x

tactic: exact (minpoly.eq_zero hx).trans (minpoly.eq_zero (mt isIntegral_iff.mpr hx)).symm
state_before: case neg
K : Type u_2
L : Type u_1
L' : Type ?u.315453
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field L'
inst✝¹ : Algebra K L
inst✝ : Algebra K L'
S : IntermediateField K L
x : { x // x ∈ S }
hx : ¬IsIntegral K x
⊢ minpoly K x = minpoly K ↑x
Theorem: Subgroup.map_commutator
File: Mathlib/GroupTheory/Commutator.lean

tactic: simp_rw [le_antisymm_iff, map_le_iff_le_comap, commutator_le, mem_comap, map_commutatorElement]
state_before: G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ map f ⁅H₁, H₂⁆ = ⁅map f H₁, map f H₂⁆

tactic: constructor
state_before: G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ (∀ (g₁ : G), g₁ ∈ H₁ → ∀ (g₂ : G), g₂ ∈ H₂ → ⁅↑f g₁, ↑f g₂⁆ ∈ ⁅map f H₁, map f H₂⁆) ∧
    ∀ (g₁ : G'), g₁ ∈ map f H₁ → ∀ (g₂ : G'), g₂ ∈ map f H₂ → ⁅g₁, g₂⁆ ∈ map f ⁅H₁, H₂⁆

tactic: intro p hp q hq
state_before: case left
G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ ∀ (g₁ : G), g₁ ∈ H₁ → ∀ (g₂ : G), g₂ ∈ H₂ → ⁅↑f g₁, ↑f g₂⁆ ∈ ⁅map f H₁, map f H₂⁆

tactic: exact commutator_mem_commutator (mem_map_of_mem _ hp) (mem_map_of_mem _ hq)
state_before: case left
G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
p : G
hp : p ∈ H₁
q : G
hq : q ∈ H₂
⊢ ⁅↑f p, ↑f q⁆ ∈ ⁅map f H₁, map f H₂⁆

tactic: rintro _ ⟨p, hp, rfl⟩ _ ⟨q, hq, rfl⟩
state_before: case right
G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ ∀ (g₁ : G'), g₁ ∈ map f H₁ → ∀ (g₂ : G'), g₂ ∈ map f H₂ → ⁅g₁, g₂⁆ ∈ map f ⁅H₁, H₂⁆

tactic: rw [← map_commutatorElement]
state_before: case right.intro.intro.intro.intro
G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
p : G
hp : p ∈ ↑H₁
q : G
hq : q ∈ ↑H₂
⊢ ⁅↑f p, ↑f q⁆ ∈ map f ⁅H₁, H₂⁆

tactic: exact mem_map_of_mem _ (commutator_mem_commutator hp hq)
state_before: case right.intro.intro.intro.intro
G : Type u_1
G' : Type u_2
F : Type ?u.88445
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
p : G
hp : p ∈ ↑H₁
q : G
hq : q ∈ ↑H₂
⊢ ↑f ⁅p, q⁆ ∈ map f ⁅H₁, H₂⁆
Theorem: CategoryTheory.Limits.snd_of_isColimit
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: apply ht.uniq (BinaryCofan.mk 0 (𝟙 Y))
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
X Y : C
t : BinaryBicone X Y
ht : IsColimit (BinaryBicone.toCocone t)
⊢ t.snd = IsColimit.desc ht (BinaryCofan.mk 0 (𝟙 Y))

tactic: rintro ⟨⟨⟩⟩ <;> dsimp <;> simp
state_before: case x
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
X Y : C
t : BinaryBicone X Y
ht : IsColimit (BinaryBicone.toCocone t)
⊢ ∀ (j : Discrete WalkingPair), (BinaryBicone.toCocone t).ι.app j ≫ t.snd = (BinaryCofan.mk 0 (𝟙 Y)).ι.app j
Theorem: Submodule.span_singleton_smul_le
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [span_le, Set.singleton_subset_iff, SetLike.mem_coe]
state_before: R : Type u_2
R₂ : Type ?u.131813
K : Type ?u.131816
M : Type u_3
M₂ : Type ?u.131822
V : Type ?u.131825
S✝ : Type ?u.131828
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁶ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R₂ M₂
s t : Set M
S : Type u_1
inst✝³ : Monoid S
inst✝² : SMul S R
inst✝¹ : MulAction S M
inst✝ : IsScalarTower S R M
r : S
x : M
⊢ span R {r • x} ≤ span R {x}

tactic: exact smul_of_tower_mem _ _ (mem_span_singleton_self _)
state_before: R : Type u_2
R₂ : Type ?u.131813
K : Type ?u.131816
M : Type u_3
M₂ : Type ?u.131822
V : Type ?u.131825
S✝ : Type ?u.131828
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁶ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R₂ M₂
s t : Set M
S : Type u_1
inst✝³ : Monoid S
inst✝² : SMul S R
inst✝¹ : MulAction S M
inst✝ : IsScalarTower S R M
r : S
x : M
⊢ r • x ∈ span R {x}
Theorem: List.sum_le_foldr_max
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' l with hd tl IH
state_before: ι : Type ?u.146362
α : Type ?u.146365
M : Type u_1
N : Type u_2
P : Type ?u.146374
M₀ : Type ?u.146377
G : Type ?u.146380
R : Type ?u.146383
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
l : List M
⊢ f (sum l) ≤ foldr max 0 (map f l)

tactic: simp only [List.sum_cons, List.foldr_map, List.foldr] at IH⊢
state_before: case cons
ι : Type ?u.146362
α : Type ?u.146365
M : Type u_1
N : Type u_2
P : Type ?u.146374
M₀ : Type ?u.146377
G : Type ?u.146380
R : Type ?u.146383
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f (sum tl) ≤ foldr max 0 (map f tl)
⊢ f (sum (hd :: tl)) ≤ foldr max 0 (map f (hd :: tl))

tactic: exact (hadd _ _).trans (max_le_max le_rfl IH)
state_before: case cons
ι : Type ?u.146362
α : Type ?u.146365
M : Type u_1
N : Type u_2
P : Type ?u.146374
M₀ : Type ?u.146377
G : Type ?u.146380
R : Type ?u.146383
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f (sum tl) ≤ foldr (fun x y => max (f x) y) 0 tl
⊢ f (hd + sum tl) ≤ max (f hd) (foldr (fun x y => max (f x) y) 0 tl)

tactic: simpa using h0
state_before: case nil
ι : Type ?u.146362
α : Type ?u.146365
M : Type u_1
N : Type u_2
P : Type ?u.146374
M₀ : Type ?u.146377
G : Type ?u.146380
R : Type ?u.146383
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
⊢ f (sum []) ≤ foldr max 0 (map f [])
Theorem: Finset.prod_range_succ
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp only [mul_comm, prod_range_succ_comm]
state_before: ι : Type ?u.432982
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x in range (n + 1), f x = (∏ x in range n, f x) * f n
Theorem: Filter.EventuallyEq.prod_mk
File: Mathlib/Order/Filter/Basic.lean

tactic: intros
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.185063
ι : Sort x
l : Filter α
f f' : α → β
hf : f =ᶠ[l] f'
g g' : α → γ
hg : g =ᶠ[l] g'
⊢ ∀ (x : α), g x = g' x → f x = f' x → (fun x => (f x, g x)) x = (fun x => (f' x, g' x)) x

tactic: simp only [*]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.185063
ι : Sort x
l : Filter α
f f' : α → β
hf : f =ᶠ[l] f'
g g' : α → γ
hg : g =ᶠ[l] g'
x✝ : α
a✝¹ : g x✝ = g' x✝
a✝ : f x✝ = f' x✝
⊢ (fun x => (f x, g x)) x✝ = (fun x => (f' x, g' x)) x✝
Theorem: Polynomial.root_left_of_root_gcd
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: cases' EuclideanDomain.gcd_dvd_left f g with p hp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : CommSemiring k
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
⊢ eval₂ ϕ α f = 0

tactic: rw [hp, Polynomial.eval₂_mul, hα, MulZeroClass.zero_mul]
state_before: case intro
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p✝ q : R[X]
inst✝ : CommSemiring k
ϕ : R →+* k
f g : R[X]
α : k
hα : eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
p : R[X]
hp : f = EuclideanDomain.gcd f g * p
⊢ eval₂ ϕ α f = 0
Theorem: Submodule.mapQ_id
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [comap_id]
state_before: R : Type ?u.284528
M : Type ?u.284531
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.285544
M₂ : Type ?u.285547
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
⊢ p ≤ comap LinearMap.id p

tactic: ext
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.285544
M₂ : Type ?u.285547
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap LinearMap.id p) (_ : p ≤ comap LinearMap.id p)
⊢ mapQ p p LinearMap.id h = LinearMap.id

tactic: simp
state_before: case h.h
R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.285544
M₂ : Type ?u.285547
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap LinearMap.id p) (_ : p ≤ comap LinearMap.id p)
x✝ : M
⊢ ↑(comp (mapQ p p LinearMap.id h) (mkQ p)) x✝ = ↑(comp LinearMap.id (mkQ p)) x✝
Theorem: Finset.image_union
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_image, mem_union, exists_prop, or_and_right, exists_or]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.85521
inst✝¹ : DecidableEq β
f✝ g : α → β
s : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
f : α → β
s₁ s₂ : Finset α
x✝ : β
⊢ x✝ ∈ image f (s₁ ∪ s₂) ↔ x✝ ∈ image f s₁ ∪ image f s₂
Theorem: MeasureTheory.continuous_setToFun
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp_rw [L1.setToFun_eq_setToL1 hT]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1555022
G : Type ?u.1555025
𝕜 : Type ?u.1555028
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ Continuous fun f => setToFun μ T hT ↑↑f

tactic: exact ContinuousLinearMap.continuous _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1555022
G : Type ?u.1555025
𝕜 : Type ?u.1555028
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ Continuous fun f => ↑(L1.setToL1 hT) f
Theorem: UniformSpace.ring_sep_quot
File: Mathlib/Topology/Algebra/UniformRing.lean

tactic: rw [@ring_sep_rel α r]
state_before: α✝ : Type ?u.323008
α : Type u
r : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)

tactic: rfl
state_before: α✝ : Type ?u.323008
α : Type u
r : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ Quotient (Submodule.quotientRel (Ideal.closure ⊥)) = (α ⧸ Ideal.closure ⊥)
Theorem: lp.norm_eq_tsum_rpow
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: dsimp [norm]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
⊢ ‖f‖ = (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)

tactic: rw [ENNReal.toReal_pos_iff] at hp
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
⊢ (if hp : p = 0 then
      Eq.rec (motive := fun x x_1 => { x_2 // x_2 ∈ lp E x } → ℝ)
        (fun f => ↑(Finset.card (Set.Finite.toFinset (_ : Set.Finite {i | ↑f i ≠ 0})))) (_ : 0 = p) f
    else if p = ⊤ then ⨆ (i : α), ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)) =
    (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)

tactic: rw [dif_neg hp.1.ne', if_neg hp.2.ne]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : 0 < p ∧ p < ⊤
f : { x // x ∈ lp E p }
⊢ (if hp : p = 0 then
      Eq.rec (motive := fun x x_1 => { x_2 // x_2 ∈ lp E x } → ℝ)
        (fun f => ↑(Finset.card (Set.Finite.toFinset (_ : Set.Finite {i | ↑f i ≠ 0})))) (_ : 0 = p) f
    else if p = ⊤ then ⨆ (i : α), ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)) =
    (∑' (i : α), ‖↑f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)
Theorem: summable_of_absolute_convergence_real
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine' summable_of_summable_norm ⟨r, (hasSum_iff_tendsto_nat_of_nonneg _ _).2 _⟩
state_before: α : Type ?u.192
β : Type ?u.195
ι : Type ?u.198
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i in Finset.range n, abs (f i)) atTop (𝓝 r)
⊢ Summable f

tactic: exact fun i ↦ norm_nonneg _
state_before: case refine'_1
α : Type ?u.192
β : Type ?u.195
ι : Type ?u.198
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i in Finset.range n, abs (f i)) atTop (𝓝 r)
⊢ ∀ (i : ℕ), 0 ≤ ‖f i‖

case refine'_2
α : Type ?u.192
β : Type ?u.195
ι : Type ?u.198
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i in Finset.range n, abs (f i)) atTop (𝓝 r)
⊢ Tendsto (fun n => ∑ i in Finset.range n, ‖f i‖) atTop (𝓝 r)

tactic: simpa only using hr
state_before: case refine'_2
α : Type ?u.192
β : Type ?u.195
ι : Type ?u.198
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i in Finset.range n, abs (f i)) atTop (𝓝 r)
⊢ Tendsto (fun n => ∑ i in Finset.range n, ‖f i‖) atTop (𝓝 r)
Theorem: Array.isEqv_self
File: src/lean/Init/Data/Array/DecidableEq.lean

tactic: simp [isEqv, isEqvAux_self]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : Array α
⊢ (isEqv a a fun x y => decide (x = y)) = true
Theorem: List.getLast_map
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with l_hd l_tl l_ih
state_before: ι : Type ?u.138776
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
hl : l ≠ []
⊢ getLast (map f l) (_ : ¬map f l = []) = f (getLast l hl)

tactic: apply (hl rfl).elim
state_before: case nil
ι : Type ?u.138776
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
hl✝ : l ≠ []
hl : [] ≠ []
⊢ getLast (map f []) (_ : ¬map f [] = []) = f (getLast [] hl)

tactic: cases l_tl
state_before: case cons
ι : Type ?u.138776
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
hl✝ : l ≠ []
l_hd : α
l_tl : List α
l_ih : ∀ (hl : l_tl ≠ []), getLast (map f l_tl) (_ : ¬map f l_tl = []) = f (getLast l_tl hl)
hl : l_hd :: l_tl ≠ []
⊢ getLast (map f (l_hd :: l_tl)) (_ : ¬map f (l_hd :: l_tl) = []) = f (getLast (l_hd :: l_tl) hl)

tactic: simp
state_before: case cons.nil
ι : Type ?u.138776
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
hl✝ : l ≠ []
l_hd : α
l_ih : ∀ (hl : [] ≠ []), getLast (map f []) (_ : ¬map f [] = []) = f (getLast [] hl)
hl : [l_hd] ≠ []
⊢ getLast (map f [l_hd]) (_ : ¬map f [l_hd] = []) = f (getLast [l_hd] hl)

tactic: simpa using l_ih _
state_before: case cons.cons
ι : Type ?u.138776
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
l : List α
hl✝ : l ≠ []
l_hd head✝ : α
tail✝ : List α
l_ih :
  ∀ (hl : head✝ :: tail✝ ≠ []),
    getLast (map f (head✝ :: tail✝)) (_ : ¬map f (head✝ :: tail✝) = []) = f (getLast (head✝ :: tail✝) hl)
hl : l_hd :: head✝ :: tail✝ ≠ []
⊢ getLast (map f (l_hd :: head✝ :: tail✝)) (_ : ¬map f (l_hd :: head✝ :: tail✝) = []) =
    f (getLast (l_hd :: head✝ :: tail✝) hl)
Theorem: AddCommGroup.ModEq.sub_iff_left
File: Mathlib/Algebra/ModEq.lean

tactic: simp [sub_sub_sub_comm, hm, sub_smul, ModEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a₁ ≡ b₁ [PMOD p]
m : ℤ
hm : b₁ - a₁ = m • p
⊢ (∃ b, b₁ - b₂ - (a₁ - a₂) = ↑(Equiv.subLeft m).symm.symm b • p) ↔ a₂ ≡ b₂ [PMOD p]
Theorem: Complex.conj_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: ⊢ (↑(starRingEnd ℂ) I).re = (-I).re ∧ (↑(starRingEnd ℂ) I).im = (-I).im
Theorem: MeasureTheory.quasiMeasurePreserving_mul_left
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: have :=
  (quasiMeasurePreserving_mul_right μ.inv g⁻¹).mono (inv_absolutelyContinuous μ.inv)
    (absolutelyContinuous_inv μ.inv)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g * h

tactic: rw [μ.inv_inv] at this
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this : QuasiMeasurePreserving fun h => h * g⁻¹
⊢ QuasiMeasurePreserving fun h => g * h

tactic: have :=
  (quasiMeasurePreserving_inv_of_right_invariant μ).comp
    (this.comp (quasiMeasurePreserving_inv_of_right_invariant μ))
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this : QuasiMeasurePreserving fun h => h * g⁻¹
⊢ QuasiMeasurePreserving fun h => g * h

tactic: simp_rw [Function.comp, mul_inv_rev, inv_inv] at this
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this✝ : QuasiMeasurePreserving fun h => h * g⁻¹
this : QuasiMeasurePreserving (Inv.inv ∘ (fun h => h * g⁻¹) ∘ Inv.inv)
⊢ QuasiMeasurePreserving fun h => g * h

tactic: exact this
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this✝ : QuasiMeasurePreserving fun h => h * g⁻¹
this : QuasiMeasurePreserving fun x => g * x
⊢ QuasiMeasurePreserving fun h => g * h
Theorem: Nat.Ico_zero_eq_range
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [← bot_eq_zero, ← Iio_eq_Ico, Iio_eq_range]
state_before: a b c : ℕ
⊢ Ico 0 = range