ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.blsub_le_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
⊢ o.blsub f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h < a
state_after: case h.e'_2.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
a✝ : Ordinal.{u}
⊢ (∀ (h : a✝ < o), f a✝ h < a) ↔ ∀ (h : a✝ < o), succ (f a✝ h) ≤ a
tactic: convert bsup_le_iff.{_, v} (f := fun a ha => succ (f a ha)) (a := a) using 2
state_before: case h.e'_2.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
a✝ : Ordinal.{u}
⊢ (∀ (h : a✝ < o), f a✝ h < a) ↔ ∀ (h : a✝ < o), succ (f a✝ h) ≤ a
state_after: no goals
tactic: simp_rw [succ_le_iff]
Theorem: Part.Fix.approx_mono'
File: Mathlib/Control/LawfulFix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
⊢ approx (⇑f) i ≤ approx (⇑f) i.succ
state_after: no goals
tactic: induction i with
  | zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
  | succ _ i_ih => intro; apply f.monotone; apply i_ih
Theorem: ImplicitFunctionData.map_nhds_eq
File: Mathlib/Analysis/Calculus/Implicit.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : CompleteSpace E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : CompleteSpace F
G : Type u_4
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace G
φ : ImplicitFunctionData 𝕜 E F G
⊢ map (Prod.fst ∘ φ.prodFun) (𝓝 φ.pt) = 𝓝 (φ.prodFun φ.pt).1
state_after: no goals
tactic: rw [← map_map, φ.hasStrictFDerivAt.map_nhds_eq_of_equiv, map_fst_nhds]
Theorem: OrderIso.equivalence_inverse
File: Mathlib/CategoryTheory/Category/Preorder.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : Preorder X
inst✝ : Preorder Y
e : X ≃o Y
x✝ : X
⊢ (𝟭 X).obj x✝ = (⋯.functor ⋙ ⋯.functor).obj x✝
state_after: no goals
tactic: simp
state_before: X : Type u
Y : Type v
inst✝¹ : Preorder X
inst✝ : Preorder Y
e : X ≃o Y
x✝ : Y
⊢ (⋯.functor ⋙ ⋯.functor).obj x✝ = (𝟭 Y).obj x✝
state_after: no goals
tactic: simp
Theorem: Prod.mk.inj_right
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
α : Type u_5
β : Type u_6
b : β
⊢ Function.Injective fun a => (a, b)
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
α : Type u_5
β : Type u_6
b : β
b₁ b₂ : α
h : (fun a => (a, b)) b₁ = (fun a => (a, b)) b₂
⊢ b₁ = b₂
tactic: intro b₁ b₂ h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
α : Type u_5
β : Type u_6
b : β
b₁ b₂ : α
h : (fun a => (a, b)) b₁ = (fun a => (a, b)) b₂
⊢ b₁ = b₂
state_after: no goals
tactic: simpa only [and_true, eq_self_iff_true, mk.inj_iff] using h
Theorem: Nat.count_le_cardinal
File: Mathlib/Data/Nat/Count.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ ↑(count p n) ≤ Cardinal.mk ↑{k | p k}
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ Cardinal.mk { k // k < n ∧ p k } ≤ Cardinal.mk ↑{k | p k}
tactic: rw [count_eq_card_fintype, ← Cardinal.mk_fintype]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ Cardinal.mk { k // k < n ∧ p k } ≤ Cardinal.mk ↑{k | p k}
state_after: no goals
tactic: exact Cardinal.mk_subtype_mono fun x hx ↦ hx.2
Theorem: LocalizedModule.induction_on₂
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
⊢ ∀ (x y : LocalizedModule S M), β x y
state_after: case mk.mk.mk.mk
R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
x✝ : LocalizedModule S M
m : M
s : ↥S
y✝ : LocalizedModule S M
m' : M
s' : ↥S
⊢ β (Quot.mk Setoid.r (m, s)) (Quot.mk Setoid.r (m', s'))
tactic: rintro ⟨⟨m, s⟩⟩ ⟨⟨m', s'⟩⟩
state_before: case mk.mk.mk.mk
R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
x✝ : LocalizedModule S M
m : M
s : ↥S
y✝ : LocalizedModule S M
m' : M
s' : ↥S
⊢ β (Quot.mk Setoid.r (m, s)) (Quot.mk Setoid.r (m', s'))
state_after: no goals
tactic: exact h m m' s s'
Theorem: PiTensorProduct.reindex_symm
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
e : ι ≃ ι₂
⊢ (reindex R (fun x => M) e).symm = reindex R (fun x => M) e.symm
state_after: case h
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
e : ι ≃ ι₂
x : ⨂[R] (i : ι₂), M
⊢ (reindex R (fun x => M) e).symm x = (reindex R (fun x => M) e.symm) x
tactic: ext x
state_before: case h
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
e : ι ≃ ι₂
x : ⨂[R] (i : ι₂), M
⊢ (reindex R (fun x => M) e).symm x = (reindex R (fun x => M) e.symm) x
state_after: no goals
tactic: simp only [reindex, domDomCongrLinearEquiv', LinearEquiv.coe_symm_mk, LinearEquiv.coe_mk,
    LinearEquiv.ofLinear_symm_apply, Equiv.symm_symm_apply, LinearEquiv.ofLinear_apply,
    Equiv.piCongrLeft'_symm]
Theorem: dense_biInter_of_isOpen
File: Mathlib/Topology/Baire/Lemmas.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂ s ∈ S, f s)
state_after: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂₀ (f '' S))
tactic: rw [← sInter_image]
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set α
f : α → Set X
ho : ∀ s ∈ S, IsOpen (f s)
hS : S.Countable
hd : ∀ s ∈ S, Dense (f s)
⊢ Dense (⋂₀ (f '' S))
state_after: no goals
tactic: refine dense_sInter_of_isOpen ?_ (hS.image _) ?_ <;> rwa [forall_mem_image]
Theorem: Nat.dist.triangle_inequality
File: Mathlib/Data/Nat/Dist.lean

Proof steps:
state_before: n m k : ℕ
⊢ n.dist k ≤ n.dist m + m.dist k
state_after: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n.dist k ≤ n.dist m + m.dist k
tactic: have : dist n m + dist m k = n - m + (m - k) + (k - m + (m - n)) := by
    simp [dist, add_comm, add_left_comm, add_assoc]
state_before: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n.dist k ≤ n.dist m + m.dist k
state_after: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n - k + (k - n) ≤ n - m + (m - k) + (k - m + (m - n))
tactic: rw [this, dist]
state_before: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n - k + (k - n) ≤ n - m + (m - k) + (k - m + (m - n))
state_after: no goals
tactic: exact add_le_add tsub_le_tsub_add_tsub tsub_le_tsub_add_tsub
Theorem: NumberField.mixedEmbedding.norm_real
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
c : ℝ
⊢ mixedEmbedding.norm (fun x => c, fun x => ↑c) = |c| ^ finrank ℚ K
state_after: no goals
tactic: rw [show ((fun _ ↦ c, fun _ ↦ c) : (E K)) = c • 1 by ext <;> simp, norm_smul, map_one, mul_one]
Theorem: WeierstrassCurve.Affine.derivative_addPolynomial_slope
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ derivative (W.addPolynomial x₁ y₁ (W.slope x₁ x₂ y₁ y₂)) =
    -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ derivative (-((X - C x₁) * (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))) =
    -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))
tactic: rw [addPolynomial_slope h₁ h₂ hxy]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ derivative (-((X - C x₁) * (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))) =
    -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ -(((1 - 0) * (X - C x₂) + (X - C x₁) * (1 - 0)) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₁) * (X - C x₂) * (1 - 0)) =
    -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))
tactic: derivative_simp
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ -(((1 - 0) * (X - C x₂) + (X - C x₁) * (1 - 0)) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₁) * (X - C x₂) * (1 - 0)) =
    -((X - C x₁) * (X - C x₂) + (X - C x₁) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) +
        (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))
state_after: no goals
tactic: ring1
Theorem: Nat.ModEq.cancel_left_of_coprime
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
hmc : m.gcd c = 1
h : c * a ≡ c * b [MOD m]
⊢ a ≡ b [MOD m]
state_after: case inl
n a b c d : ℕ
hmc : gcd 0 c = 1
h : c * a ≡ c * b [MOD 0]
⊢ a ≡ b [MOD 0]

case inr
m n a b c d : ℕ
hmc : m.gcd c = 1
h : c * a ≡ c * b [MOD m]
hm : m > 0
⊢ a ≡ b [MOD m]
tactic: rcases m.eq_zero_or_pos with (rfl | hm)
state_before: case inr
m n a b c d : ℕ
hmc : m.gcd c = 1
h : c * a ≡ c * b [MOD m]
hm : m > 0
⊢ a ≡ b [MOD m]
state_after: no goals
tactic: simpa [hmc] using h.cancel_left_div_gcd hm
Theorem: div_le_div_iff_right
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c✝ d c : α
⊢ a / c ≤ b / c ↔ a ≤ b
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
Theorem: Finset.mem_shadow_iff_exists_sdiff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ 𝒜 ↔ ∃ s ∈ 𝒜, t ⊆ s ∧ (s \ t).card = 1
state_after: no goals
tactic: simp_rw [mem_shadow_iff, ← covBy_iff_card_sdiff_eq_one, covBy_iff_exists_erase]
Theorem: CauSeq.add_equiv_add
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 + g1 ≈ f2 + g2
state_after: no goals
tactic: simpa only [← add_sub_add_comm] using add_limZero hf hg
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.of_comp
File: Mathlib/AlgebraicTopology/DoldKan/Faces.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y Z : C
q n : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
f : Z ⟶ Y
j : Fin (n + 1)
hj : n + 1 ≤ ↑j + q
⊢ (f ≫ φ) ≫ X.δ j.succ = 0
state_after: no goals
tactic: rw [assoc, v j hj, comp_zero]
Theorem: Complex.selfAdjointEquiv_symm_apply
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
⊢ ∀ (x y : ↥(selfAdjoint ℂ)), (fun z => (↑z).re) (x + y) = (fun z => (↑z).re) x + (fun z => (↑z).re) y
state_after: no goals
tactic: simp
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
⊢ ∀ (m : ℝ) (x : ↥(selfAdjoint ℂ)),
    { toFun := fun z => (↑z).re, map_add' := ⋯ }.toFun (m • x) =
      (RingHom.id ℝ) m • { toFun := fun z => (↑z).re, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp
Theorem: ae_eq_const_or_norm_setIntegral_lt_of_norm_le_const
File: Mathlib/Analysis/Convex/Integral.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂μ.restrict t, ‖f x‖ ≤ C
⊢ f =ᶠ[ae (μ.restrict t)] const α (⨍ (x : α) in t, f x ∂μ) ∨ ‖∫ (x : α) in t, f x ∂μ‖ < (μ t).toReal * C
state_after: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂μ.restrict t, ‖f x‖ ≤ C
this : Fact (μ t < ⊤)
⊢ f =ᶠ[ae (μ.restrict t)] const α (⨍ (x : α) in t, f x ∂μ) ∨ ‖∫ (x : α) in t, f x ∂μ‖ < (μ t).toReal * C
tactic: haveI := Fact.mk ht.lt_top
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂μ.restrict t, ‖f x‖ ≤ C
this : Fact (μ t < ⊤)
⊢ f =ᶠ[ae (μ.restrict t)] const α (⨍ (x : α) in t, f x ∂μ) ∨ ‖∫ (x : α) in t, f x ∂μ‖ < (μ t).toReal * C
state_after: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂μ.restrict t, ‖f x‖ ≤ C
this : Fact (μ t < ⊤)
⊢ f =ᶠ[ae (μ.restrict t)] const α (⨍ (x : α) in t, f x ∂μ) ∨ ‖∫ (x : α) in t, f x ∂μ‖ < ((μ.restrict t) univ).toReal * C
tactic: rw [← restrict_apply_univ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂μ.restrict t, ‖f x‖ ≤ C
this : Fact (μ t < ⊤)
⊢ f =ᶠ[ae (μ.restrict t)] const α (⨍ (x : α) in t, f x ∂μ) ∨ ‖∫ (x : α) in t, f x ∂μ‖ < ((μ.restrict t) univ).toReal * C
state_after: no goals
tactic: exact ae_eq_const_or_norm_integral_lt_of_norm_le_const h_le
Theorem: CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_obj
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingMultispan I.fstFrom I.sndFrom),
    (Multicofork.ofSigmaCofork I K₁).ι.app j ≫ f.hom = (Multicofork.ofSigmaCofork I K₂).ι.app j
state_after: case left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.L
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.left a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.left a✝)

case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
tactic: rintro (_ | _)
state_before: case left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.L
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.left a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.left a✝)

case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
state_after: case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
tactic: { simp [-Multicofork.fst_app_right] }
state_before: case right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork I.fstSigmaMap I.sndSigmaMap
f : K₁ ⟶ K₂
a✝ : I.R
⊢ (Multicofork.ofSigmaCofork I K₁).ι.app (WalkingMultispan.right a✝) ≫ f.hom =
    (Multicofork.ofSigmaCofork I K₂).ι.app (WalkingMultispan.right a✝)
state_after: no goals
tactic: { simp [-Multicofork.ofSigmaCofork_pt] }
Theorem: MeasureTheory.dirac_ne_dirac
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
a : α
inst✝ : MeasurableSpace.SeparatesPoints α
x y : α
x_ne_y : x ≠ y
⊢ dirac x ≠ dirac y
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
a : α
inst✝ : MeasurableSpace.SeparatesPoints α
x y : α
x_ne_y : x ≠ y
A : Set α
A_mble : MeasurableSet A
x_in_A : x ∈ A
y_notin_A : y ∉ A
⊢ dirac x ≠ dirac y
tactic: obtain ⟨A, A_mble, x_in_A, y_notin_A⟩ := exists_measurableSet_of_ne x_ne_y
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
a : α
inst✝ : MeasurableSpace.SeparatesPoints α
x y : α
x_ne_y : x ≠ y
A : Set α
A_mble : MeasurableSet A
x_in_A : x ∈ A
y_notin_A : y ∉ A
⊢ dirac x ≠ dirac y
state_after: no goals
tactic: exact dirac_ne_dirac_iff_exists_measurableSet.mpr ⟨A, A_mble, x_in_A, y_notin_A⟩
Theorem: Finsupp.span_single_image
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set M
a : α
⊢ span R (single a '' s) = map (lsingle a) (span R s)
state_after: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set M
a : α
⊢ span R (single a '' s) = span R (⇑(lsingle a) '' s)
tactic: rw [← span_image]
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set M
a : α
⊢ span R (single a '' s) = span R (⇑(lsingle a) '' s)
state_after: no goals
tactic: rfl
Theorem: rank_range_add_rank_ker
File: Mathlib/LinearAlgebra/Dimension/RankNullity.lean

Proof steps:
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
f : M →ₗ[R] M₁
⊢ Module.rank R ↥(LinearMap.range f) + Module.rank R ↥(LinearMap.ker f) = Module.rank R M
state_after: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
f : M →ₗ[R] M₁
this : (p : Submodule R M) → DecidableEq (M ⧸ p)
⊢ Module.rank R ↥(LinearMap.range f) + Module.rank R ↥(LinearMap.ker f) = Module.rank R M
tactic: haveI := fun p : Submodule R M => Classical.decEq (M ⧸ p)
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
inst✝ : HasRankNullity.{u, u_1} R
f : M →ₗ[R] M₁
this : (p : Submodule R M) → DecidableEq (M ⧸ p)
⊢ Module.rank R ↥(LinearMap.range f) + Module.rank R ↥(LinearMap.ker f) = Module.rank R M
state_after: no goals
tactic: rw [← f.quotKerEquivRange.rank_eq, rank_quotient_add_rank]
Theorem: IsOpen.closure_add
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s✝ t : Set G
ht : IsOpen t
s : Set G
⊢ closure s * t = s * t
state_after: no goals
tactic: rw [← inv_inv (closure s * t), mul_inv_rev, inv_closure, ht.inv.mul_closure, mul_inv_rev, inv_inv,
    inv_inv]