tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.AEEqFun.integrable_mk
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [Integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1262382
δ : Type ?u.1262385
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ Integrable (mk f hf) ↔ MeasureTheory.Integrable f

tactic: apply integrable_congr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1262382
δ : Type ?u.1262385
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ MeasureTheory.Integrable ↑(mk f hf) ↔ MeasureTheory.Integrable f

tactic: exact coeFn_mk f hf
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.1262382
δ : Type ?u.1262385
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ ↑(mk f hf) =ᵐ[μ] f
Theorem: Set.right_mem_Iic
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.5871
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Iic a
Theorem: MvPolynomial.isHomogeneous_monomial
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: intro c hc
state_before: σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
⊢ IsHomogeneous (↑(monomial d) r) n

tactic: rw [coeff_monomial] at hc
state_before: σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
c : σ →₀ ℕ
hc : coeff c (↑(monomial d) r) ≠ 0
⊢ ∑ i in c.support, ↑c i = n

tactic: split_ifs at hc with h
state_before: σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
hc : (if d = c then r else 0) ≠ 0
⊢ ∑ i in c.support, ↑c i = n

tactic: subst c
state_before: case inl
σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
h : d = c
hc : r ≠ 0
⊢ ∑ i in c.support, ↑c i = n

tactic: exact hn
state_before: case inl
σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
hc✝ : r ≠ 0
hc : coeff d (↑(monomial d) r) ≠ 0
⊢ ∑ i in d.support, ↑d i = n

tactic: contradiction
state_before: case inr
σ : Type u_1
τ : Type ?u.126597
R : Type u_2
S : Type ?u.126603
inst✝ : CommSemiring R
d : σ →₀ ℕ
r : R
n : ℕ
hn : ∑ i in d.support, ↑d i = n
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
h : ¬d = c
hc : 0 ≠ 0
⊢ ∑ i in c.support, ↑c i = n
Theorem: Nat.le_div_two_iff_mul_two_le
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [Nat.le_div_iff_mul_le zero_lt_two, ← Int.ofNat_le, Int.ofNat_mul, Nat.cast_two]
state_before: n m : ℕ
⊢ m ≤ n / 2 ↔ ↑m * 2 ≤ ↑n
Theorem: OrderIso.continuous
File: Mathlib/Topology/Algebra/Order/MonotoneContinuity.lean

tactic: rw [‹OrderTopology β›.topology_eq_generate_intervals]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
⊢ Continuous ↑e

tactic: refine' continuous_generateFrom fun s hs => _
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
⊢ Continuous ↑e

tactic: rcases hs with ⟨a, rfl | rfl⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
s : Set β
hs : s ∈ {s | ∃ a, s = Ioi a ∨ s = Iio a}
⊢ IsOpen (↑e ⁻¹' s)

tactic: rw [e.preimage_Ioi]
state_before: case intro.inl
α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
a : β
⊢ IsOpen (↑e ⁻¹' Ioi a)

tactic: apply isOpen_lt'
state_before: case intro.inl
α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
a : β
⊢ IsOpen (Ioi (↑(symm e) a))

tactic: rw [e.preimage_Iio]
state_before: case intro.inr
α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
a : β
⊢ IsOpen (↑e ⁻¹' Iio a)

tactic: apply isOpen_gt'
state_before: case intro.inr
α : Type u_1
β : Type u_2
inst✝⁵ : PartialOrder α
inst✝⁴ : PartialOrder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology α
inst✝ : OrderTopology β
e : α ≃o β
a : β
⊢ IsOpen (Iio (↑(symm e) a))
Theorem: Mathlib.Tactic.Ring.pow_atom
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
b : ℕ
⊢ a ^ b = a ^ b * Nat.rawCast 1 + 0
Theorem: ciSup_of_empty
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iSup_of_empty', csSup_empty]
state_before: α : Type u_2
β : Type ?u.72243
γ : Type ?u.72246
ι : Sort u_1
inst✝¹ : ConditionallyCompleteLinearOrderBot α
inst✝ : IsEmpty ι
f : ι → α
⊢ (⨆ (i : ι), f i) = ⊥
Theorem: ConjClasses.mem_carrier_iff_mk_eq
File: Mathlib/Algebra/Group/Conj.lean

tactic: revert b
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
b : ConjClasses α
⊢ a ∈ carrier b ↔ ConjClasses.mk a = b

tactic: rw [forall_isConj]
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ {b : ConjClasses α}, a ∈ carrier b ↔ ConjClasses.mk a = b

tactic: intro b
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ (a_1 : α), a ∈ carrier (ConjClasses.mk a_1) ↔ ConjClasses.mk a = ConjClasses.mk a_1

tactic: rw [carrier, eq_comm, mk_eq_mk_iff_isConj, ← quotient_mk_eq_mk, Quotient.lift_mk]
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ carrier (ConjClasses.mk b) ↔ ConjClasses.mk a = ConjClasses.mk b

tactic: rfl
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ conjugatesOf b ↔ IsConj b a
Theorem: TopCat.openEmbedding_iff_comp_isIso'
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: simp only [←Functor.map_comp]
state_before: X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso g
⊢ OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding ((forget TopCat).map f)

tactic: exact openEmbedding_iff_comp_isIso f g
state_before: X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso g
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) ↔ OpenEmbedding ((forget TopCat).map f)
Theorem: Finsupp.zipWith_neLocus_eq_left
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_4
M : Type u_2
N : Type u_1
P : Type u_3
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq N
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f : α →₀ M
g₁ g₂ : α →₀ N
hF : ∀ (f : M), Function.Injective fun g => F f g
⊢ neLocus (zipWith F F0 f g₁) (zipWith F F0 f g₂) = neLocus g₁ g₂

tactic: simpa only [mem_neLocus] using (hF _).ne_iff
state_before: case a
α : Type u_4
M : Type u_2
N : Type u_1
P : Type u_3
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq N
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f : α →₀ M
g₁ g₂ : α →₀ N
hF : ∀ (f : M), Function.Injective fun g => F f g
a✝ : α
⊢ a✝ ∈ neLocus (zipWith F F0 f g₁) (zipWith F F0 f g₂) ↔ a✝ ∈ neLocus g₁ g₂
Theorem: Filter.IsBoundedUnder.sup
File: Mathlib/Order/LiminfLimsup.lean

tactic: filter_upwards [hu, hv]with _ using sup_le_sup
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.40673
ι : Type ?u.40676
inst✝ : SemilatticeSup α
f : Filter β
u v : β → α
bu : α
hu : ∀ᶠ (x : β) in f, u x ≤ bu
bv : α
hv : ∀ᶠ (x : β) in f, v x ≤ bv
⊢ ∀ᶠ (x : β) in f, u x ⊔ v x ≤ bu ⊔ bv
Theorem: TensorPower.one_mul
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: rw [gMul_def, gOne_def]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
a : (⨂[R]^n) M
⊢ ↑(cast R M (_ : 0 + n = n)) (GradedMonoid.GMul.mul GradedMonoid.GOne.one a) = a

tactic: induction' a using PiTensorProduct.induction_on with r a x y hx hy
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
a : (⨂[R]^n) M
⊢ ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] a)) = a

tactic: dsimp only at a
state_before: case C1
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
⊢ ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] (r • ↑(tprod R) a))) = r • ↑(tprod R) a

tactic: rw [TensorProduct.tmul_smul, LinearEquiv.map_smul, LinearEquiv.map_smul, ← gMul_def,
  tprod_mul_tprod, cast_tprod]
state_before: case C1
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
⊢ ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] (r • ↑(tprod R) a))) = r • ↑(tprod R) a

tactic: congr 2 with i
state_before: case C1
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
⊢ r • ↑(tprod R) (Fin.append Fin.elim0' a ∘ ↑(Fin.cast (_ : n = 0 + n))) = r • ↑(tprod R) a

tactic: rw [Fin.elim0'_append]
state_before: case C1.e_a.h.e_6.h.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
i : Fin n
⊢ (Fin.append Fin.elim0' a ∘ ↑(Fin.cast (_ : n = 0 + n))) i = a i

tactic: refine' congr_arg a (Fin.ext _)
state_before: case C1.e_a.h.e_6.h.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
i : Fin n
⊢ ((a ∘ ↑(Fin.cast (_ : 0 + n = n))) ∘ ↑(Fin.cast (_ : n = 0 + n))) i = a i

tactic: simp
state_before: case C1.e_a.h.e_6.h.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
r : R
a : Fin n → M
i : Fin n
⊢ ↑(↑(Fin.cast (_ : 0 + n = n)) (↑(Fin.cast (_ : n = 0 + n)) i)) = ↑i

tactic: rw [TensorProduct.tmul_add, map_add, map_add, hx, hy]
state_before: case Cp
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
x y : ⨂[R] (i : Fin n), M
hx : ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] x)) = x
hy : ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] y)) = y
⊢ ↑(cast R M (_ : 0 + n = n)) (↑mulEquiv (↑(tprod R) Fin.elim0' ⊗ₜ[R] (x + y))) = x + y
Theorem: Finset.image_image
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [image_val, dedup_map_dedup_eq, Multiset.map_map]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
inst✝¹ : DecidableEq β
f g✝ : α → β
s : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq γ
g : β → γ
⊢ (image g (image f s)).val = (image (g ∘ f) s).val
Theorem: Asymptotics.isBigO_norm_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def]
state_before: α : Type u_1
β : Type ?u.123733
E : Type ?u.123736
F : Type u_2
G : Type ?u.123742
E' : Type u_3
F' : Type ?u.123748
G' : Type ?u.123751
E'' : Type ?u.123754
F'' : Type ?u.123757
G'' : Type ?u.123760
R : Type ?u.123763
R' : Type ?u.123766
𝕜 : Type ?u.123769
𝕜' : Type ?u.123772
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (fun x => ‖f' x‖) =O[l] g ↔ f' =O[l] g

tactic: exact exists_congr fun _ => isBigOWith_norm_left
state_before: α : Type u_1
β : Type ?u.123733
E : Type ?u.123736
F : Type u_2
G : Type ?u.123742
E' : Type u_3
F' : Type ?u.123748
G' : Type ?u.123751
E'' : Type ?u.123754
F'' : Type ?u.123757
G'' : Type ?u.123760
R : Type ?u.123763
R' : Type ?u.123766
𝕜 : Type ?u.123769
𝕜' : Type ?u.123772
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (∃ c, IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∃ c, IsBigOWith c l f' g
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.respectsIso
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: apply RespectsIso.of_respects_arrow_iso
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.20586
inst✝ : Category D
P : MorphismProperty C
hP : StableUnderBaseChange P
⊢ RespectsIso P

tactic: intro f g e
state_before: case hP
C : Type u
inst✝¹ : Category C
D : Type ?u.20586
inst✝ : Category D
P : MorphismProperty C
hP : StableUnderBaseChange P
⊢ ∀ (f g : Arrow C), (f ≅ g) → P f.hom → P g.hom

tactic: exact hP (IsPullback.of_horiz_isIso (CommSq.mk e.inv.w))
state_before: case hP
C : Type u
inst✝¹ : Category C
D : Type ?u.20586
inst✝ : Category D
P : MorphismProperty C
hP : StableUnderBaseChange P
f g : Arrow C
e : f ≅ g
⊢ P f.hom → P g.hom
Theorem: cardinal_mk_eq_cardinal_mk_field_pow_rank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: let s := Basis.ofVectorSpaceIndex K V
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ (#V) = (#K) ^ Module.rank K V

tactic: let hs := Basis.ofVectorSpace K V
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
⊢ (#V) = (#K) ^ Module.rank K V

tactic: calc
  (#V) = (#s →₀ K) := Quotient.sound ⟨hs.repr.toEquiv⟩
  _ = (#s → K) := (Quotient.sound ⟨Finsupp.equivFunOnFinite⟩)
  _ = _ := by rw [← Cardinal.lift_inj.1 hs.mk_eq_rank, Cardinal.power_def]
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
hs : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ (#V) = (#K) ^ Module.rank K V

tactic: rw [← Cardinal.lift_inj.1 hs.mk_eq_rank, Cardinal.power_def]
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
hs : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ (#↑s → K) = (#K) ^ Module.rank K V
Theorem: connectedComponentIn_subset
File: Mathlib/Topology/Connected.lean

tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type ?u.51675
π : ι → Type ?u.51680
inst✝ : TopologicalSpace α
s t u v F : Set α
x : α
⊢ connectedComponentIn F x ⊆ F

tactic: split_ifs <;> simp
state_before: α : Type u
β : Type v
ι : Type ?u.51675
π : ι → Type ?u.51680
inst✝ : TopologicalSpace α
s t u v F : Set α
x : α
⊢ (if h : x ∈ F then Subtype.val '' connectedComponent { val := x, property := h } else ∅) ⊆ F
Theorem: transGen_of_succ_of_reflexive
File: Mathlib/Order/SuccPred/Relation.lean

tactic: rcases eq_or_ne m n with (rfl | hmn)
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hr : Reflexive r
h1 : ∀ (i : α), i ∈ Ico n m → r i (succ i)
h2 : ∀ (i : α), i ∈ Ico m n → r (succ i) i
⊢ TransGen r n m

tactic: exact transGen_of_succ_of_ne r h1 h2 hmn.symm
state_before: case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
hr : Reflexive r
h1 : ∀ (i : α), i ∈ Ico n m → r i (succ i)
h2 : ∀ (i : α), i ∈ Ico m n → r (succ i) i
hmn : m ≠ n
⊢ TransGen r n m

tactic: exact TransGen.single (hr m)
state_before: case inl
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
m : α
hr : Reflexive r
h1 : ∀ (i : α), i ∈ Ico m m → r i (succ i)
h2 : ∀ (i : α), i ∈ Ico m m → r (succ i) i
⊢ TransGen r m m
Theorem: CategoryTheory.eqToHom_unop
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases h
state_before: C : Type u₁
inst✝ : Category C
X Y : Cᵒᵖ
h : X = Y
⊢ (eqToHom h).unop = eqToHom (_ : Y.unop = X.unop)

tactic: rfl
state_before: case refl
C : Type u₁
inst✝ : Category C
X : Cᵒᵖ
⊢ (eqToHom (_ : X = X)).unop = eqToHom (_ : X.unop = X.unop)
Theorem: Set.WellFoundedOn.induction
File: Mathlib/Order/WellFoundedSet.lean

tactic: let Q : s → Prop := fun y => P y
state_before: ι : Type ?u.4297
α : Type u_1
β : Type ?u.4303
r r' : α → α → Prop
s t : Set α
x y : α
hs : WellFoundedOn s r
hx : x ∈ s
P : α → Prop
hP : ∀ (y : α), y ∈ s → (∀ (z : α), z ∈ s → r z y → P z) → P y
⊢ P x

tactic: change Q ⟨x, hx⟩
state_before: ι : Type ?u.4297
α : Type u_1
β : Type ?u.4303
r r' : α → α → Prop
s t : Set α
x y : α
hs : WellFoundedOn s r
hx : x ∈ s
P : α → Prop
hP : ∀ (y : α), y ∈ s → (∀ (z : α), z ∈ s → r z y → P z) → P y
Q : ↑s → Prop := fun y => P ↑y
⊢ P x

tactic: refine' WellFounded.induction hs ⟨x, hx⟩ _
state_before: ι : Type ?u.4297
α : Type u_1
β : Type ?u.4303
r r' : α → α → Prop
s t : Set α
x y : α
hs : WellFoundedOn s r
hx : x ∈ s
P : α → Prop
hP : ∀ (y : α), y ∈ s → (∀ (z : α), z ∈ s → r z y → P z) → P y
Q : ↑s → Prop := fun y => P ↑y
⊢ Q { val := x, property := hx }

tactic: simpa only [Subtype.forall]
state_before: ι : Type ?u.4297
α : Type u_1
β : Type ?u.4303
r r' : α → α → Prop
s t : Set α
x y : α
hs : WellFoundedOn s r
hx : x ∈ s
P : α → Prop
hP : ∀ (y : α), y ∈ s → (∀ (z : α), z ∈ s → r z y → P z) → P y
Q : ↑s → Prop := fun y => P ↑y
⊢ ∀ (x : ↑s), (∀ (y : ↑s), r ↑y ↑x → Q y) → Q x
Theorem: Stream'.WSeq.exists_of_liftRel_left
File: Mathlib/Data/Seq/WSeq.lean

tactic: let ⟨n, h⟩ := exists_get?_of_mem h
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
a : α
h : a ∈ s
⊢ ∃ b, b ∈ t ∧ R a b

tactic: dsimp only [get?, head] at h
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
a : α
h✝ : a ∈ s
n : ℕ
h : some a ∈ get? s n
⊢ ∃ b, b ∈ t ∧ R a b

tactic: let ⟨some (_, s'), sd, rfl⟩ := Computation.exists_of_mem_map h
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
a : α
h✝ : a ∈ s
n : ℕ
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s n))
⊢ ∃ b, b ∈ t ∧ R a b

tactic: let ⟨some (b, t'), td, ⟨ab, _⟩⟩ := (liftRel_dropn_destruct H n).left sd
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
H : LiftRel R s t
a : α
h✝ : a ∈ s
n : ℕ
h : some a ∈ Computation.map (fun x => Prod.fst <$> x) (destruct (drop s n))
s' : WSeq α
sd : some (a, s') ∈ destruct (drop s n)
⊢ ∃ b, b ∈ t ∧ R a b
Theorem: NNReal.not_summable_iff_tendsto_nat_atTop
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: constructor
state_before: α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
⊢ ¬Summable f ↔ Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop

tactic: intro h
state_before: case mp
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
⊢ ¬Summable f → Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop

tactic: refine' ((tendsto_of_monotone _).resolve_right h).comp _
state_before: case mp
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop

tactic: exacts [Finset.sum_mono_set _, tendsto_finset_range]
state_before: case mp.refine'_1
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Monotone fun s => ∑ b in s, f b

case mp.refine'_2
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
h : ¬Summable f
⊢ Tendsto (fun n => Finset.range n) atTop atTop

tactic: rintro hnat ⟨r, hr⟩
state_before: case mpr
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
⊢ Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop → ¬Summable f

tactic: exact not_tendsto_nhds_of_tendsto_atTop hnat _ (hasSum_iff_tendsto_nat.1 hr)
state_before: case mpr.intro
α : Type ?u.312905
β : Type ?u.312908
γ : Type ?u.312911
f : ℕ → ℝ≥0
hnat : Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop
r : ℝ≥0
hr : HasSum f r
⊢ False
Theorem: Linarith.mul_neg
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simpa
state_before: α : Type u_1
inst✝ : StrictOrderedRing α
a b : α
ha : a < 0
hb : 0 < b
this : -b * a > 0
⊢ 0 < -(b * a)
Theorem: CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_none
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ (pullbackConeOfLeftIso f g).π.app none = g
Theorem: List.sublists_map
File: Mathlib/Data/List/Sublists.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
⊢ sublists (map f []) = map (map f) (sublists [])

tactic: rw [map_cons, sublists_cons, bind_eq_bind, sublists_map f l, sublists_cons,
  bind_eq_bind, map_eq_bind, map_eq_bind]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
l : List α
⊢ sublists (map f (a :: l)) = map (map f) (sublists (a :: l))

tactic: induction sublists l <;> simp [*]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
l : List α
⊢ (List.bind (List.bind (sublists l) fun x => [map f x]) fun x => [x, f a :: x]) =
    List.bind (List.bind (sublists l) fun x => [x, a :: x]) fun x => [map f x]
Theorem: Cubic.eq_sum_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: apply_fun @toPoly _ _
state_before: R : Type ?u.935152
S : Type ?u.935155
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ map φ P =
    { a := ↑φ P.a, b := ↑φ P.a * -(x + y + z), c := ↑φ P.a * (x * y + x * z + y * z), d := ↑φ P.a * -(x * y * z) }

tactic: rw [eq_prod_three_roots ha h3, C_mul_prod_X_sub_C_eq]
state_before: R : Type ?u.935152
S : Type ?u.935155
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ toPoly (map φ P) =
    toPoly
      { a := ↑φ P.a, b := ↑φ P.a * -(x + y + z), c := ↑φ P.a * (x * y + x * z + y * z), d := ↑φ P.a * -(x * y * z) }

tactic: exact fun P Q ↦ (toPoly_injective P Q).mp
state_before: case inj
R : Type ?u.935152
S : Type ?u.935155
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ Function.Injective toPoly