ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.pow_mul_meas_ge_le_eLpNorm
File: Mathlib/MeasureTheory/Function/LpSeminorm/ChebyshevMarkov.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal}) ^ (1 / p.toReal) ≤ eLpNorm f p μ
state_after: α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal}) ^ (1 / p.toReal) ≤ (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)
tactic: rw [eLpNorm_eq_lintegral_rpow_nnnorm hp_ne_zero hp_ne_top]
state_before: α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal}) ^ (1 / p.toReal) ≤ (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)
state_after: case h₁
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal} ≤ ∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ
tactic: gcongr
state_before: case h₁
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal} ≤ ∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ
state_after: no goals
tactic: exact mul_meas_ge_le_lintegral₀ (hf.ennnorm.pow_const _) ε
Theorem: tendsto_Iio_atTop
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Iio a)
⊢ Tendsto f l atTop ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Iio a)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[<] a) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] a)
tactic: rw [← comap_coe_Iio_nhdsWithin_Iio, tendsto_comap_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Iio a)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[<] a) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[<] a)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
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 α
m : MeasurableSpace α
T : Set α → F →L[ℝ] F'
c : ℝ
f : α →ₛ F
⊢ setToSimpleFunc (fun s => c • T s) f = c • setToSimpleFunc T f
state_after: no goals
tactic: simp_rw [setToSimpleFunc, ContinuousLinearMap.smul_apply, smul_sum]
Theorem: hasDerivAt_circleMap
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ HasDerivAt (circleMap c R) (circleMap 0 R θ * I) θ
state_after: no goals
tactic: simpa only [mul_assoc, one_mul, ofRealCLM_apply, circleMap, ofReal_one, zero_add]
    using (((ofRealCLM.hasDerivAt (x := θ)).mul_const I).cexp.const_mul (R : ℂ)).const_add c
Theorem: FixedPoints.rank_le_card
File: Mathlib/FieldTheory/Fixed.lean

Proof steps:
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
s : Finset F
hs : LinearIndependent ↥(subfield G F) fun i => ↑i
⊢ s.card ≤ Fintype.card G
state_after: no goals
tactic: simpa only [rank_fun', Cardinal.mk_coe_finset, Finset.coe_sort_coe, Cardinal.lift_natCast,
      Cardinal.natCast_le] using
      (linearIndependent_smul_of_linearIndependent G F hs).cardinal_lift_le_rank
Theorem: minimals_eq_minimals_of_subset_of_forall
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
⊢ minimals r s = minimals r t
state_after: case refine_1
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
a : α
x✝ : a ∈ minimals r s
has : a ∈ s
hmin : ∀ ⦃b : α⦄, b ∈ s → r b a → r a b
⊢ a ∈ t

case refine_2
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
a : α
x✝ : a ∈ minimals r t
hat : a ∈ t
hmin : ∀ ⦃b : α⦄, b ∈ t → r b a → r a b
b : α
hbs : b ∈ s
hba : r b a
⊢ r a b
tactic: refine Set.ext fun a ↦ ⟨fun ⟨has, hmin⟩ ↦ ⟨?_,fun b hbt ↦ hmin (hts hbt)⟩,
    fun ⟨hat, hmin⟩ ↦ ⟨hts hat, fun b hbs hba ↦ ?_⟩⟩
state_before: case refine_2
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
a : α
x✝ : a ∈ minimals r t
hat : a ∈ t
hmin : ∀ ⦃b : α⦄, b ∈ t → r b a → r a b
b : α
hbs : b ∈ s
hba : r b a
⊢ r a b
state_after: case refine_2.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
a : α
x✝ : a ∈ minimals r t
hat : a ∈ t
hmin : ∀ ⦃b : α⦄, b ∈ t → r b a → r a b
b : α
hbs : b ∈ s
hba : r b a
b' : α
hb't : b' ∈ t
hb'b : r b' b
⊢ r a b
tactic: obtain ⟨b', hb't, hb'b⟩ := h b hbs
state_before: case refine_2.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝¹ : IsAntisymm α r
inst✝ : IsTrans α r
hts : t ⊆ s
h : ∀ x ∈ s, ∃ y ∈ t, r y x
a : α
x✝ : a ∈ minimals r t
hat : a ∈ t
hmin : ∀ ⦃b : α⦄, b ∈ t → r b a → r a b
b : α
hbs : b ∈ s
hba : r b a
b' : α
hb't : b' ∈ t
hb'b : r b' b
⊢ r a b
state_after: no goals
tactic: rwa [antisymm (hmin hb't (Trans.trans hb'b hba)) (Trans.trans hb'b hba)]
Theorem: Set.image2_union_inter_subset_union
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∪ s') (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s (t ∩ t') ∪ image2 f s' (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'
tactic: rw [image2_union_left]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s (t ∩ t') ∪ image2 f s' (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'
state_after: no goals
tactic: exact
    union_subset_union (image2_subset_left inter_subset_left)
      (image2_subset_left inter_subset_right)
Theorem: MeasureTheory.eLpNorm'_eq_zero_of_ae_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
hf_zero : f =ᶠ[ae μ] 0
⊢ eLpNorm' f q μ = 0
state_after: no goals
tactic: rw [eLpNorm'_congr_ae hf_zero, eLpNorm'_zero hq0_lt]
Theorem: Trivialization.isImage_preimage_prod
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace F E)
e✝ : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace F E
b : B
y : E b
B' : Type u_6
inst✝ : TopologicalSpace B'
e : Trivialization F proj
s : Set B
x : Z
hx : x ∈ e.source
⊢ ↑e.toPartialHomeomorph x ∈ s ×ˢ univ ↔ x ∈ proj ⁻¹' s
state_after: no goals
tactic: simp [e.coe_fst', hx]
Theorem: Asymptotics.isBigOWith_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
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 α
⊢ IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖
state_after: no goals
tactic: rw [IsBigOWith_def]
Theorem: Int.abs_eq_normalize
File: Mathlib/Algebra/GCDMonoid/Nat.lean

Proof steps:
state_before: z : ℤ
⊢ |z| = normalize z
state_after: no goals
tactic: cases le_total 0 z <;> simp [-normalize_apply, normalize_of_nonneg, normalize_of_nonpos, *]
Theorem: Nat.nth_apply_eq_orderIsoOfNat
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
n : ℕ
⊢ nth p n = ↑((Subtype.orderIsoOfNat (setOf p)) n)
state_after: no goals
tactic: rw [nth, dif_neg hf]
Theorem: HasDerivAtFilter.scomp
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hg : HasDerivAtFilter g₁ g₁' (h x) L'
hh : HasDerivAtFilter h h' x L
hL : Tendsto h L L'
⊢ HasDerivAtFilter (g₁ ∘ h) (h' • g₁') x L
state_after: no goals
tactic: simpa using ((hg.restrictScalars 𝕜).comp x hh hL).hasDerivAtFilter
Theorem: List.Chain'.count_not_le_count_add_one
File: Mathlib/Data/Bool/Count.lean

Proof steps:
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ count (!b) l ≤ count b l + 1
state_after: case nil
b : Bool
hl : Chain' (fun x x_1 => x ≠ x_1) []
⊢ count (!b) [] ≤ count b [] + 1

case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!b) (x :: l) ≤ count b (x :: l) + 1
tactic: cases' l with x l
state_before: case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!b) (x :: l) ≤ count b (x :: l) + 1
state_after: case cons.inl
b : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (b :: l)
⊢ count (!b) (b :: l) ≤ count b (b :: l) + 1

case cons.inr
x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!!x) (x :: l) ≤ count (!x) (x :: l) + 1
tactic: obtain rfl | rfl : b = x ∨ b = !x := by simp only [Bool.eq_not_iff, em]
Theorem: MvPolynomial.IsHomogeneous.map
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n : ℕ
hφ : φ.IsHomogeneous n
f : R →+* S
⊢ ((MvPolynomial.map f) φ).IsHomogeneous n
state_after: no goals
tactic: simpa only [one_mul] using hφ.eval₂ _ _ (fun r ↦ isHomogeneous_C _ (f r)) (isHomogeneous_X _)
Theorem: MeasurableSpace.comap_compl
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m' : MeasurableSpace β
inst✝ : BooleanAlgebra β
h : Measurable compl
f : α → β
⊢ MeasurableSpace.comap (fun a => (f a)ᶜ) inferInstance = MeasurableSpace.comap f inferInstance
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m' : MeasurableSpace β
inst✝ : BooleanAlgebra β
h : Measurable compl
f : α → β
⊢ MeasurableSpace.comap f (MeasurableSpace.comap compl inferInstance) = MeasurableSpace.comap f inferInstance
tactic: rw [← Function.comp_def, ← MeasurableSpace.comap_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m' : MeasurableSpace β
inst✝ : BooleanAlgebra β
h : Measurable compl
f : α → β
⊢ MeasurableSpace.comap f (MeasurableSpace.comap compl inferInstance) = MeasurableSpace.comap f inferInstance
state_after: case e_m
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m' : MeasurableSpace β
inst✝ : BooleanAlgebra β
h : Measurable compl
f : α → β
⊢ MeasurableSpace.comap compl inferInstance = inferInstance
tactic: congr
state_before: case e_m
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m' : MeasurableSpace β
inst✝ : BooleanAlgebra β
h : Measurable compl
f : α → β
⊢ MeasurableSpace.comap compl inferInstance = inferInstance
state_after: no goals
tactic: exact (MeasurableEquiv.ofInvolutive _ compl_involutive h).measurableEmbedding.comap_eq
Theorem: Real.sinh_eq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ ↑(sinh x) = ↑((rexp x - rexp (-x)) / 2)
state_after: no goals
tactic: simp [Complex.sinh]
Theorem: Cardinal.mk_preimage_down
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
s : Set α
⊢ #↑(ULift.down ⁻¹' s) = lift.{v, u} #↑s
state_after: α β : Type u
s : Set α
⊢ Nonempty (↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s)
tactic: rw [← mk_uLift, Cardinal.eq]
state_before: α β : Type u
s : Set α
⊢ Nonempty (↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s)
state_after: case val
α β : Type u
s : Set α
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
tactic: constructor
state_before: case val
α β : Type u
s : Set α
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
state_after: case val
α β : Type u
s : Set α
f : ↑(ULift.down ⁻¹' s) → ULift.{?u.6919, u} ↑s := fun x => { down := s.restrictPreimage ULift.down x }
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
tactic: let f : ULift.down ⁻¹' s → ULift s := fun x ↦ ULift.up (restrictPreimage s ULift.down x)
state_before: case val
α β : Type u
s : Set α
f : ↑(ULift.down ⁻¹' s) → ULift.{?u.6919, u} ↑s := fun x => { down := s.restrictPreimage ULift.down x }
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
state_after: case val
α β : Type u
s : Set α
f : ↑(ULift.down ⁻¹' s) → ULift.{?u.6966, u} ↑s := fun x => { down := s.restrictPreimage ULift.down x }
this : Bijective f
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
tactic: have : Function.Bijective f :=
    ULift.up_bijective.comp (restrictPreimage_bijective _ (ULift.down_bijective))
state_before: case val
α β : Type u
s : Set α
f : ↑(ULift.down ⁻¹' s) → ULift.{?u.6966, u} ↑s := fun x => { down := s.restrictPreimage ULift.down x }
this : Bijective f
⊢ ↑(ULift.down ⁻¹' s) ≃ ULift.{v, u} ↑s
state_after: no goals
tactic: exact Equiv.ofBijective f this
Theorem: Finset.card_le_card_of_forall_subsingleton
File: Mathlib/Combinatorics/Enumerative/DoubleCounting.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝¹ : DecidablePred (r a)
inst✝ : (a : α) → Decidable (r a b)
m n : ℕ
hs : ∀ a ∈ s, ∃ b ∈ t, r a b
ht : ∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton
⊢ s.card ≤ t.card
state_after: no goals
tactic: classical
    rw [← mul_one s.card, ← mul_one t.card]
    exact card_mul_le_card_mul r
      (fun a h ↦ card_pos.2 (by
        rw [← coe_nonempty, coe_bipartiteAbove]
        exact hs _ h : (t.bipartiteAbove r a).Nonempty))
      (fun b h ↦ card_le_one.2 (by
        simp_rw [mem_bipartiteBelow]
        exact ht _ h))
Theorem: memPartitionSet_eq_iff
File: Mathlib/Data/Set/MemPartition.lean

Proof steps:
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
⊢ memPartitionSet f n a = s ↔ a ∈ s
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
⊢ memPartitionSet f n a = s
tactic: refine ⟨fun h ↦ h ▸ mem_memPartitionSet f n a, fun h ↦ ?_⟩
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
⊢ memPartitionSet f n a = s
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
⊢ False
tactic: by_contra h_ne
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
⊢ False
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ False
tactic: have h_disj : Disjoint s (memPartitionSet f n a) :=
    disjoint_memPartition f n hs (memPartitionSet_mem f n a) (Ne.symm h_ne)
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ False
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ ¬Disjoint s (memPartitionSet f n a)
tactic: refine absurd h_disj ?_
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ ¬Disjoint s (memPartitionSet f n a)
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ (s ∩ memPartitionSet f n a).Nonempty
tactic: rw [not_disjoint_iff_nonempty_inter]
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
s : Set α
hs : s ∈ memPartition f n
h : a ∈ s
h_ne : ¬memPartitionSet f n a = s
h_disj : Disjoint s (memPartitionSet f n a)
⊢ (s ∩ memPartitionSet f n a).Nonempty
state_after: no goals
tactic: exact ⟨a, h, mem_memPartitionSet f n a⟩
Theorem: Set.image_finset_sum_pi
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
⊢ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S = ∏ i ∈ l, S i
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
x✝ : α
⊢ x✝ ∈ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S ↔ x✝ ∈ ∏ i ∈ l, S i
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
x✝ : α
⊢ x✝ ∈ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S ↔ x✝ ∈ ∏ i ∈ l, S i
state_after: no goals
tactic: simp_rw [mem_finset_prod, mem_image, mem_pi, exists_prop, Finset.mem_coe]
Theorem: Embedding.prod_map
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : X → Y
g : Z → W
hf : _root_.Embedding f
hg : _root_.Embedding g
x✝¹ x✝ : X × Z
x₁ : X
z₁ : Z
x₂ : X
z₂ : Z
⊢ Prod.map f g (x₁, z₁) = Prod.map f g (x₂, z₂) → (x₁, z₁) = (x₂, z₂)
state_after: no goals
tactic: simp [hf.inj.eq_iff, hg.inj.eq_iff]
Theorem: isEmpty_prod
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
α : Type u_4
β : Type u_5
⊢ IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_prod, not_and_or]
Theorem: Relation.ReflTransGen.cases_head_iff
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ ReflTransGen r a b ↔ a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) → ReflTransGen r a b
tactic: use cases_head
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) → ReflTransGen r a b
state_after: case mpr.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a c d : α
⊢ ReflTransGen r a a

case mpr.inr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c✝ d c : α
hac : r a c
hcb : ReflTransGen r c b
⊢ ReflTransGen r a b
tactic: rintro (rfl | ⟨c, hac, hcb⟩)
Theorem: WithTop.top_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
hb : b ≠ 0
⊢ ⊤ * b = ⊤
state_after: no goals
tactic: rw [top_mul', if_neg hb]
Theorem: Finset.centerMass_singleton
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hw : w i ≠ 0
⊢ {i}.centerMass w z = z i
state_after: no goals
tactic: rw [centerMass, sum_singleton, sum_singleton, ← mul_smul, inv_mul_cancel hw, one_smul]
Theorem: List.IsPrefix.get_eq
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
x y : List α
h : x <+: y
n : ℕ
hn : n < x.length
⊢ x.get ⟨n, hn⟩ = y.get ⟨n, ⋯⟩
state_after: no goals
tactic: simp only [get_eq_getElem, IsPrefix.getElem h hn]
Theorem: Fin.succAbove_eq_zero_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
b : Fin n
ha : a ≠ 0
⊢ a.succAbove b = 0 ↔ b = 0
state_after: no goals
tactic: rw [← succAbove_ne_zero_zero ha, succAbove_right_inj]