ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.Coloring.toPartition_parts
File: Mathlib/Combinatorics/SimpleGraph/Partition.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : G.Coloring α
⊢ ∀ s ∈ C.colorClasses, IsAntichain G.Adj s
state_after: case intro
V : Type u
G : SimpleGraph V
α : Type v
C : G.Coloring α
c : V
⊢ IsAntichain G.Adj {x | (Setoid.ker ⇑C).Rel x c}
tactic: rintro s ⟨c, rfl⟩
state_before: case intro
V : Type u
G : SimpleGraph V
α : Type v
C : G.Coloring α
c : V
⊢ IsAntichain G.Adj {x | (Setoid.ker ⇑C).Rel x c}
state_after: no goals
tactic: apply C.color_classes_independent
Theorem: Set.exists_subset_range_iff
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∃ s, ∃ (_ : s ⊆ range f), p s) ↔ ∃ s, p (f '' s)
state_after: no goals
tactic: simp
Theorem: AddSubgroup.neg_subset_closure
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ S : Set G
s : G
hs : s ∈ S⁻¹
⊢ s ∈ ↑(closure S)
state_after: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ S : Set G
s : G
hs : s ∈ S⁻¹
⊢ s⁻¹ ∈ closure S
tactic: rw [SetLike.mem_coe, ← Subgroup.inv_mem_iff]
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ S : Set G
s : G
hs : s ∈ S⁻¹
⊢ s⁻¹ ∈ closure S
state_after: no goals
tactic: exact subset_closure (mem_inv.mp hs)
Theorem: PMF.toOuterMeasure_caratheodory
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
⊢ p.toOuterMeasure.caratheodory = ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
⊢ ⊤ ≤ x
tactic: refine eq_top_iff.2 <| le_trans (le_sInf fun x hx => ?_) (le_sum_caratheodory _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
⊢ ⊤ ≤ x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
y : α
hy : (fun i => (p i • dirac i).caratheodory) y = x
⊢ ⊤ ≤ x
tactic: have ⟨y, hy⟩ := hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
y : α
hy : (fun i => (p i • dirac i).caratheodory) y = x
⊢ ⊤ ≤ x
state_after: no goals
tactic: exact
    ((le_of_eq (dirac_caratheodory y).symm).trans (le_smul_caratheodory _ _)).trans (le_of_eq hy)
Theorem: Real.mk_pos
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < mk f ↔ f.Pos
state_after: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < f ↔ f.Pos
tactic: rw [← mk_zero, mk_lt]
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < f ↔ f.Pos
state_after: no goals
tactic: exact iff_of_eq (congr_arg Pos (sub_zero f))
Theorem: List.rtake_nil
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ [].rtake n = []
state_after: no goals
tactic: simp [rtake]
Theorem: Polynomial.coeff_mul_mirror
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ (p * p.mirror).coeff (p.natDegree + p.natTrailingDegree) = p.sum fun n x => x ^ 2
state_after: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ ∑ k ∈ Finset.range (p.natDegree + p.natTrailingDegree).succ,
      p.coeff (k, p.natDegree + p.natTrailingDegree - k).1 *
        p.mirror.coeff (k, p.natDegree + p.natTrailingDegree - k).2 =
    p.sum fun n x => x ^ 2
tactic: rw [coeff_mul, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk]
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
n : ℕ
hn : n ∈ Finset.range (p.natDegree + p.natTrailingDegree).succ
⊢ p.coeff (n, p.natDegree + p.natTrailingDegree - n).1 * p.mirror.coeff (n, p.natDegree + p.natTrailingDegree - n).2 =
    p.coeff n ^ 2
state_after: no goals
tactic: rw [coeff_mirror, ← revAt_le (Finset.mem_range_succ_iff.mp hn), revAt_invol, ← sq]
Theorem: List.IsSuffix.isInfix
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
x✝ : l₁ <:+ l₂
t : List α✝
h : t ++ l₁ = l₂
⊢ t ++ l₁ ++ [] = l₂
state_after: no goals
tactic: rw [h, append_nil]
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_self
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a - a = 0
state_after: no goals
tactic: rw [sub_def, ← Category.comp_id a, ← prod.comp_lift, Category.assoc, diag_σ, comp_zero]
Theorem: groupCohomology.dZero_apply
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : CoeSort.coe A
g : G
⊢ (fun m g => (A.ρ g) m - m) (x + y) g = ((fun m g => (A.ρ g) m - m) x + (fun m g => (A.ρ g) m - m) y) g
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : CoeSort.coe A
g : G
⊢ (A.ρ g) x - x + ((A.ρ g) y - y) = ((fun g => (A.ρ g) x - x) + fun g => (A.ρ g) y - y) g
tactic: simp only [map_add, add_sub_add_comm]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : CoeSort.coe A
g : G
⊢ (A.ρ g) x - x + ((A.ρ g) y - y) = ((fun g => (A.ρ g) x - x) + fun g => (A.ρ g) y - y) g
state_after: no goals
tactic: rfl
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : CoeSort.coe A
g : G
⊢ { toFun := fun m g => (A.ρ g) m - m, map_add' := ⋯ }.toFun (r • x) g =
    ((RingHom.id k) r • { toFun := fun m g => (A.ρ g) m - m, map_add' := ⋯ }.toFun x) g
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : CoeSort.coe A
g : G
⊢ (A.ρ g) (r • x) - r • x = r • ((A.ρ g) x - x)
tactic: dsimp
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : CoeSort.coe A
g : G
⊢ (A.ρ g) (r • x) - r • x = r • ((A.ρ g) x - x)
state_after: no goals
tactic: rw [map_smul, smul_sub]
Theorem: StarAlgHom.prodEquiv_symm_apply
File: Mathlib/Algebra/Star/StarAlgHom.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : (A →⋆ₐ[R] B) × (A →⋆ₐ[R] C)
⊢ (fun f => ((fst R B C).comp f, (snd R B C).comp f)) ((fun f => f.1.prod f.2) f) = f
state_after: no goals
tactic: ext <;> rfl
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : A →⋆ₐ[R] B × C
⊢ (fun f => f.1.prod f.2) ((fun f => ((fst R B C).comp f, (snd R B C).comp f)) f) = f
state_after: no goals
tactic: ext <;> rfl
Theorem: contravariant_flip_iff
File: Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
mu : N → N → N
inst✝ : IsSymmOp N N mu
⊢ Contravariant N N (flip mu) r ↔ Contravariant N N mu r
state_after: no goals
tactic: rw [IsSymmOp.flip_eq]
Theorem: Set.mem_univ_pi
File: Mathlib/Data/Set/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
ι : Type u_1
α : ι → Type u_2
s : Set ι
t : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ f ∈ univ.pi t ↔ ∀ (i : ι), f i ∈ t i
state_after: no goals
tactic: simp
Theorem: SimpleGraph.Walk.support_transfer
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u✝ v✝ u' v' : V
p✝ : G.Walk u✝ v✝
u v : V
p : G.Walk u v
H : SimpleGraph V
hp : ∀ e ∈ p.edges, e ∈ H.edgeSet
⊢ (p.transfer H hp).support = p.support
state_after: no goals
tactic: induction p <;> simp [*]
Theorem: RelEmbedding.sumLexMap_apply
File: Mathlib/Order/RelIso/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
g : t ↪r u
⊢ ∀ {a b : α ⊕ γ},
    Sum.Lex s u ({ toFun := Sum.map ⇑f ⇑g, inj' := ⋯ } a) ({ toFun := Sum.map ⇑f ⇑g, inj' := ⋯ } b) ↔ Sum.Lex r t a b
state_after: no goals
tactic: rintro (a | b) (c | d) <;> simp [f.map_rel_iff, g.map_rel_iff]
Theorem: Real.tan_sq_div_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : cos x ≠ 0
⊢ tan x ^ 2 / (1 + tan x ^ 2) = sin x ^ 2
state_after: no goals
tactic: simp only [← tan_mul_cos hx, mul_pow, ← inv_one_add_tan_sq hx, div_eq_mul_inv, one_mul]
Theorem: LieSubmodule.map_bot
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
⊢ map f ⊥ = ⊥
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m : M'
⊢ m ∈ map f ⊥ ↔ m ∈ ⊥
tactic: ext m
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m : M'
⊢ m ∈ map f ⊥ ↔ m ∈ ⊥
state_after: no goals
tactic: simp [eq_comm]
Theorem: PrimeMultiset.prod_smul
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: d : ℕ
u : PrimeMultiset
⊢ (d • u).prod = u.prod ^ d
state_after: no goals
tactic: induction d with
  | zero => simp only [Nat.zero_eq, zero_nsmul, pow_zero, prod_zero]
  | succ n ih => rw [succ_nsmul, prod_add, ih, pow_succ]
Theorem: MeasureTheory.integrableOn_finite_iUnion
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
inst✝ : Finite β
t : β → Set α
⊢ IntegrableOn f (⋃ i, t i) μ ↔ ∀ (i : β), IntegrableOn f (t i) μ
state_after: case intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
inst✝ : Finite β
t : β → Set α
val✝ : Fintype β
⊢ IntegrableOn f (⋃ i, t i) μ ↔ ∀ (i : β), IntegrableOn f (t i) μ
tactic: cases nonempty_fintype β
state_before: case intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
inst✝ : Finite β
t : β → Set α
val✝ : Fintype β
⊢ IntegrableOn f (⋃ i, t i) μ ↔ ∀ (i : β), IntegrableOn f (t i) μ
state_after: no goals
tactic: simpa using @integrableOn_finset_iUnion _ _ _ _ _ f μ Finset.univ t
Theorem: SimpleGraph.Subgraph.Connected.preconnected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Connected
⊢ H.Preconnected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Preconnected ∧ H.verts.Nonempty
⊢ H.Preconnected
tactic: rw [H.connected_iff] at h
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
h : H.Preconnected ∧ H.verts.Nonempty
⊢ H.Preconnected
state_after: no goals
tactic: exact h.1
Theorem: MeasureTheory.Filtration.memℒp_limitProcess_of_eLpNorm_bdd
File: Mathlib/Probability/Process/Filtration.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : Preorder ι
E : Type u_4
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ℱ✝ : Filtration ι m
f✝ : ι → Ω → E
μ : Measure Ω
R : ℝ≥0
p : ℝ≥0∞
F : Type u_5
inst✝ : NormedAddCommGroup F
ℱ : Filtration ℕ m
f : ℕ → Ω → F
hfm : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
⊢ Memℒp (limitProcess f ℱ μ) p μ
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : Preorder ι
E : Type u_4
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ℱ✝ : Filtration ι m
f✝ : ι → Ω → E
μ : Measure Ω
R : ℝ≥0
p : ℝ≥0∞
F : Type u_5
inst✝ : NormedAddCommGroup F
ℱ : Filtration ℕ m
f : ℕ → Ω → F
hfm : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
⊢ Memℒp
    (if h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω)) then Classical.choose h
    else 0)
    p μ
tactic: rw [limitProcess]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : Preorder ι
E : Type u_4
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ℱ✝ : Filtration ι m
f✝ : ι → Ω → E
μ : Measure Ω
R : ℝ≥0
p : ℝ≥0∞
F : Type u_5
inst✝ : NormedAddCommGroup F
ℱ : Filtration ℕ m
f : ℕ → Ω → F
hfm : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
⊢ Memℒp
    (if h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω)) then Classical.choose h
    else 0)
    p μ
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : Preorder ι
E : Type u_4
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ℱ✝ : Filtration ι m
f✝ : ι → Ω → E
μ : Measure Ω
R : ℝ≥0
p : ℝ≥0∞
F : Type u_5
inst✝ : NormedAddCommGroup F
ℱ : Filtration ℕ m
f : ℕ → Ω → F
hfm : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ Memℒp (Classical.choose h) p μ

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : Preorder ι
E : Type u_4
inst✝² : Zero E
inst✝¹ : TopologicalSpace E
ℱ✝ : Filtration ι m
f✝ : ι → Ω → E
μ : Measure Ω
R : ℝ≥0
p : ℝ≥0∞
F : Type u_5
inst✝ : NormedAddCommGroup F
ℱ : Filtration ℕ m
f : ℕ → Ω → F
hfm : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
h : ¬∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ Memℒp 0 p μ
tactic: split_ifs with h
Theorem: Algebra.EssFiniteType.comp
File: Mathlib/RingTheory/EssentialFiniteness.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
h₁ : EssFiniteType R S
h₂ : EssFiniteType S T
⊢ EssFiniteType R T
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
h₁ : ∃ σ, ∀ (s : S), ∃ t ∈ adjoin R ↑σ, IsUnit t ∧ s * t ∈ adjoin R ↑σ
h₂ : ∃ σ, ∀ (s : T), ∃ t ∈ adjoin S ↑σ, IsUnit t ∧ s * t ∈ adjoin S ↑σ
⊢ ∃ σ, ∀ (s : T), ∃ t ∈ adjoin R ↑σ, IsUnit t ∧ s * t ∈ adjoin R ↑σ
tactic: rw [essFiniteType_iff] at h₁ h₂ ⊢
Theorem: AlgebraicGeometry.Scheme.Pullback.cocycle_snd_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      t' 𝒰 f g j k i ≫
        t' 𝒰 f g k i j ≫
          pullback.snd (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
            pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫ pullback.snd (𝒰.map i ≫ f) g =
    pullback.snd (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
      pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k) ≫ pullback.snd (𝒰.map i ≫ f) g
state_after: no goals
tactic: simp only [pullback.condition_assoc, t'_snd_fst_snd]
Theorem: Turing.PartrecToTM2.supports_insert
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: K S : Finset Λ'
q : Λ'
⊢ Supports (insert q K) S ↔ TM2.SupportsStmt S (tr q) ∧ Supports K S
state_after: no goals
tactic: simp [Supports]
Theorem: FractionalIdeal.map_div
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁶ : CommRing R₁
K : Type u_4
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J
state_after: case pos
R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁶ : CommRing R₁
K : Type u_4
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
H : J = 0
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J

case neg
R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁶ : CommRing R₁
K : Type u_4
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
H : ¬J = 0
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J
tactic: by_cases H : J = 0
Theorem: Finmap.sigma_keys_lookup
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
⊢ (s.keys.sigma fun i => (lookup i s).toFinset) = { val := s.entries, nodup := ⋯ }
state_after: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
tactic: ext x
state_before: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
state_after: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
this : x ∈ s.entries → x.fst ∈ s.keys
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
tactic: have : x ∈ s.entries → x.1 ∈ s.keys := Multiset.mem_map_of_mem _
state_before: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
this : x ∈ s.entries → x.fst ∈ s.keys
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
state_after: no goals
tactic: simpa [lookup_eq_some_iff]
Theorem: ExistsContDiffBumpBase.w_def
File: Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean

Proof steps:
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
⊢ w D = fun x => ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
state_after: case h
E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ w D x = ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
tactic: ext1 x
state_before: case h
E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
D : ℝ
x : E
⊢ w D x = ((∫ (x : E), u x ∂μ) * |D| ^ finrank ℝ E)⁻¹ • u (D⁻¹ • x)
state_after: no goals
tactic: rfl
Theorem: uniqueDiffWithinAt_univ
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
⊢ UniqueDiffWithinAt 𝕜 univ x
state_after: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
⊢ Dense ↑(Submodule.span 𝕜 univ) ∧ x ∈ closure univ
tactic: rw [uniqueDiffWithinAt_iff, tangentCone_univ]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
⊢ Dense ↑(Submodule.span 𝕜 univ) ∧ x ∈ closure univ
state_after: no goals
tactic: simp
Theorem: lowerClosure_sUnion
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
S : Set (Set α)
⊢ lowerClosure (⋃₀ S) = ⨆ s ∈ S, lowerClosure s
state_after: no goals
tactic: simp_rw [sUnion_eq_biUnion, lowerClosure_iUnion]