ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SemilatInfCat.Iso.mk_hom_toInfHom_toFun
File: Mathlib/Order/Category/Semilat.lean

Proof steps:
state_before: α β : SemilatInfCat
e : α.X ≃o β.X
⊢ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } = 𝟙 α
state_after: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : SemilatInfCat
e : α.X ≃o β.X
⊢ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } = 𝟙 β
state_after: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Filter.eventually_prod_iff
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
⊢ (∀ᶠ (x : α × β) in f ×ˢ g, p x) ↔
    ∃ pa, (∀ᶠ (x : α) in f, pa x) ∧ ∃ pb, (∀ᶠ (y : β) in g, pb y) ∧ ∀ {x : α}, pa x → ∀ {y : β}, pb y → p (x, y)
state_after: no goals
tactic: simpa only [Set.prod_subset_iff] using @mem_prod_iff α β p f g
Theorem: MeasureTheory.upcrossingsBefore_zero'
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
⊢ upcrossingsBefore a b f 0 = 0
state_after: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
ω : Ω
⊢ upcrossingsBefore a b f 0 ω = 0 ω
tactic: ext ω
state_before: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
ω : Ω
⊢ upcrossingsBefore a b f 0 ω = 0 ω
state_after: no goals
tactic: exact upcrossingsBefore_zero
Theorem: expNegInvGlue.tendsto_polynomial_inv_mul_zero
File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

Proof steps:
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) (𝓝 0) (𝓝 0)
state_after: p : ℝ[X]
⊢ Tendsto (fun x => if x ≤ 0 then 0 else Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0) (𝓝 0)
tactic: simp only [expNegInvGlue, mul_ite, mul_zero]
state_before: p : ℝ[X]
⊢ Tendsto (fun x => if x ≤ 0 then 0 else Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0) (𝓝 0)
state_after: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | ¬x ≤ 0}) (𝓝 0)
tactic: refine tendsto_const_nhds.if ?_
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | ¬x ≤ 0}) (𝓝 0)
state_after: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)
tactic: simp only [not_le]
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)
state_after: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹) (𝓝[>] 0) (𝓝 0)
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)
tactic: have : Tendsto (fun x ↦ p.eval x⁻¹ / exp x⁻¹) (𝓝[>] 0) (𝓝 0) :=
    p.tendsto_div_exp_atTop.comp tendsto_inv_zero_atTop
state_before: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹) (𝓝[>] 0) (𝓝 0)
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)
state_after: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹) (𝓝[>] 0) (𝓝 0)
x : ℝ
hx : x ∈ {x | 0 < x}
⊢ x ∈ {x | (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹ = (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) x) x}
tactic: refine this.congr' <| mem_of_superset self_mem_nhdsWithin fun x hx ↦ ?_
state_before: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹) (𝓝[>] 0) (𝓝 0)
x : ℝ
hx : x ∈ {x | 0 < x}
⊢ x ∈ {x | (fun x => Polynomial.eval x⁻¹ p / rexp x⁻¹ = (fun x => Polynomial.eval x⁻¹ p * rexp (-x⁻¹)) x) x}
state_after: no goals
tactic: simp [expNegInvGlue, hx.out.not_le, exp_neg, div_eq_mul_inv]
Theorem: iteratedDeriv_succ'
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv (n + 1) f = iteratedDeriv n (deriv f)
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ deriv^[n + 1] f = deriv^[n] (deriv f)
tactic: rw [iteratedDeriv_eq_iterate, iteratedDeriv_eq_iterate]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ deriv^[n + 1] f = deriv^[n] (deriv f)
state_after: no goals
tactic: rfl
Theorem: Function.mulSupport_extend_one
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M'
g : α → N
hf : Injective f
⊢ f '' mulSupport g ⊆ mulSupport (extend f g 1)
state_after: case intro.intro
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M'
g : α → N
hf : Injective f
x : α
hx : x ∈ mulSupport g
⊢ f x ∈ mulSupport (extend f g 1)
tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M'
g : α → N
hf : Injective f
x : α
hx : x ∈ mulSupport g
⊢ f x ∈ mulSupport (extend f g 1)
state_after: no goals
tactic: rwa [mem_mulSupport, hf.extend_apply]
Theorem: Primrec.dom_bool₂
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : Bool → Bool → α
x✝ : Bool × Bool
a b : Bool
⊢ (bif (a, b).1 then f true (a, b).2 else f false (a, b).2) = f (a, b).1 (a, b).2
state_after: no goals
tactic: cases a <;> rfl
Theorem: LaurentPolynomial.degree_C_mul_T_le
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
⊢ (C a * T n).degree ≤ ↑n
state_after: case pos
R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a = 0
⊢ (C a * T n).degree ≤ ↑n

case neg
R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : ¬a = 0
⊢ (C a * T n).degree ≤ ↑n
tactic: by_cases a0 : a = 0
Theorem: Equiv.Perm.set_support_apply_mem
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
p✝ q p : Perm α
a : α
⊢ p a ∈ {x | p x ≠ x} ↔ a ∈ {x | p x ≠ x}
state_after: no goals
tactic: simp
Theorem: AddSubmonoid.mk_eq_zero
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
a : M
ha : a ∈ S
⊢ ⟨a, ha⟩ = 1 ↔ a = 1
state_after: no goals
tactic: simp [← SetLike.coe_eq_coe]
Theorem: List.formPerm_apply_get_zero
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ 0 < l.length
state_after: no goals
tactic: omega
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ l.formPerm (l.get ⟨0, ⋯⟩) = l.get ⟨1, hl⟩
state_after: no goals
tactic: simp_all [formPerm_apply_getElem_zero]
Theorem: MeasureTheory.Integrable.abs
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Integrable f μ
⊢ Integrable (fun a => |f a|) μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Memℒp f 1 μ
⊢ Memℒp (fun a => |f a|) 1 μ
tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Memℒp f 1 μ
⊢ Memℒp (fun a => |f a|) 1 μ
state_after: no goals
tactic: exact hf.abs
Theorem: affineSpan_eq_bot
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
⊢ affineSpan k s = ⊥ ↔ s = ∅
state_after: no goals
tactic: rw [← not_iff_not, ← Ne, ← Ne, ← nonempty_iff_ne_bot, affineSpan_nonempty,
    nonempty_iff_ne_empty]
Theorem: IsExtrFilter.congr
File: Mathlib/Order/Filter/Extr.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
h : IsExtrFilter f l a
heq : f =ᶠ[l] g
hfga : f a = g a
⊢ IsExtrFilter g l a
state_after: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
h : IsMinFilter f l a ∨ IsMaxFilter f l a
heq : f =ᶠ[l] g
hfga : f a = g a
⊢ IsMinFilter g l a ∨ IsMaxFilter g l a
tactic: rw [IsExtrFilter] at *
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
h : IsMinFilter f l a ∨ IsMaxFilter f l a
heq : f =ᶠ[l] g
hfga : f a = g a
⊢ IsMinFilter g l a ∨ IsMaxFilter g l a
state_after: no goals
tactic: rwa [← heq.isMaxFilter_iff hfga, ← heq.isMinFilter_iff hfga]
Theorem: rank_quotient_add_rank_of_isDomain
File: Mathlib/LinearAlgebra/Dimension/Localization.lean

Proof steps:
state_before: R : Type u
S : Type u'
M : Type v
N : Type v'
inst✝¹¹ : CommRing R
inst✝¹⁰ : CommRing S
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Algebra R S
inst✝⁴ : Module S N
inst✝³ : IsScalarTower R S N
p : Submonoid R
inst✝² : IsLocalization p S
f : M →ₗ[R] N
inst✝¹ : IsLocalizedModule p f
hp : p ≤ R⁰
inst✝ : IsDomain R
M' : Submodule R M
⊢ Module.rank R (M ⧸ M') + Module.rank R ↥M' = Module.rank R M
state_after: case a
R : Type u
S : Type u'
M : Type v
N : Type v'
inst✝¹¹ : CommRing R
inst✝¹⁰ : CommRing S
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Algebra R S
inst✝⁴ : Module S N
inst✝³ : IsScalarTower R S N
p : Submonoid R
inst✝² : IsLocalization p S
f : M →ₗ[R] N
inst✝¹ : IsLocalizedModule p f
hp : p ≤ R⁰
inst✝ : IsDomain R
M' : Submodule R M
⊢ lift.{max u v, v} (Module.rank R (M ⧸ M') + Module.rank R ↥M') = lift.{max u v, v} (Module.rank R M)
tactic: apply lift_injective.{max u v}
state_before: case a
R : Type u
S : Type u'
M : Type v
N : Type v'
inst✝¹¹ : CommRing R
inst✝¹⁰ : CommRing S
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Algebra R S
inst✝⁴ : Module S N
inst✝³ : IsScalarTower R S N
p : Submonoid R
inst✝² : IsLocalization p S
f : M →ₗ[R] N
inst✝¹ : IsLocalizedModule p f
hp : p ≤ R⁰
inst✝ : IsDomain R
M' : Submodule R M
⊢ lift.{max u v, v} (Module.rank R (M ⧸ M') + Module.rank R ↥M') = lift.{max u v, v} (Module.rank R M)
state_after: no goals
tactic: rw [lift_add, ← IsLocalizedModule.lift_rank_eq (FractionRing R) R⁰ (M'.toLocalized R⁰) le_rfl,
    ← IsLocalizedModule.lift_rank_eq (FractionRing R) R⁰ (LocalizedModule.mkLinearMap R⁰ M) le_rfl,
    ← IsLocalizedModule.lift_rank_eq (FractionRing R) R⁰ (M'.toLocalizedQuotient R⁰) le_rfl,
    ← lift_add, rank_quotient_add_rank_of_divisionRing]
Theorem: Module.Projective.of_split
File: Mathlib/Algebra/Module/Projective.lean

Proof steps:
state_before: R : Type u
inst✝¹¹ : Ring R
P : Type v
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : Module R P
R₀ : Type ?u.49012
M : Type u_1
N : Type ?u.52304
inst✝⁸ : CommRing R₀
inst✝⁷ : Algebra R₀ R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R₀ M
inst✝⁴ : Module R M
inst✝³ : IsScalarTower R₀ R M
inst✝² : AddCommGroup N
inst✝¹ : Module R₀ N
inst✝ : Projective R M
i : P →ₗ[R] M
s : M →ₗ[R] P
H : s ∘ₗ i = LinearMap.id
⊢ Projective R P
state_after: case intro
R : Type u
inst✝¹¹ : Ring R
P : Type v
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : Module R P
R₀ : Type ?u.49012
M : Type u_1
N : Type ?u.52304
inst✝⁸ : CommRing R₀
inst✝⁷ : Algebra R₀ R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R₀ M
inst✝⁴ : Module R M
inst✝³ : IsScalarTower R₀ R M
inst✝² : AddCommGroup N
inst✝¹ : Module R₀ N
inst✝ : Projective R M
i : P →ₗ[R] M
s : M →ₗ[R] P
H : s ∘ₗ i = LinearMap.id
g : M →ₗ[R] P →₀ R
hg : Finsupp.total P P R id ∘ₗ g = s
⊢ Projective R P
tactic: obtain ⟨g, hg⟩ := projective_lifting_property (Finsupp.total P P R id) s
    (fun x ↦ ⟨Finsupp.single x 1, by simp⟩)
state_before: case intro
R : Type u
inst✝¹¹ : Ring R
P : Type v
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : Module R P
R₀ : Type ?u.49012
M : Type u_1
N : Type ?u.52304
inst✝⁸ : CommRing R₀
inst✝⁷ : Algebra R₀ R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R₀ M
inst✝⁴ : Module R M
inst✝³ : IsScalarTower R₀ R M
inst✝² : AddCommGroup N
inst✝¹ : Module R₀ N
inst✝ : Projective R M
i : P →ₗ[R] M
s : M →ₗ[R] P
H : s ∘ₗ i = LinearMap.id
g : M →ₗ[R] P →₀ R
hg : Finsupp.total P P R id ∘ₗ g = s
⊢ Projective R P
state_after: case intro
R : Type u
inst✝¹¹ : Ring R
P : Type v
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : Module R P
R₀ : Type ?u.49012
M : Type u_1
N : Type ?u.52304
inst✝⁸ : CommRing R₀
inst✝⁷ : Algebra R₀ R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R₀ M
inst✝⁴ : Module R M
inst✝³ : IsScalarTower R₀ R M
inst✝² : AddCommGroup N
inst✝¹ : Module R₀ N
inst✝ : Projective R M
i : P →ₗ[R] M
s : M →ₗ[R] P
H : s ∘ₗ i = LinearMap.id
g : M →ₗ[R] P →₀ R
hg : Finsupp.total P P R id ∘ₗ g = s
x : P
⊢ (Finsupp.total P P R id) ((g ∘ₗ i) x) = x
tactic: refine ⟨g.comp i, fun x ↦ ?_⟩
state_before: case intro
R : Type u
inst✝¹¹ : Ring R
P : Type v
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : Module R P
R₀ : Type ?u.49012
M : Type u_1
N : Type ?u.52304
inst✝⁸ : CommRing R₀
inst✝⁷ : Algebra R₀ R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R₀ M
inst✝⁴ : Module R M
inst✝³ : IsScalarTower R₀ R M
inst✝² : AddCommGroup N
inst✝¹ : Module R₀ N
inst✝ : Projective R M
i : P →ₗ[R] M
s : M →ₗ[R] P
H : s ∘ₗ i = LinearMap.id
g : M →ₗ[R] P →₀ R
hg : Finsupp.total P P R id ∘ₗ g = s
x : P
⊢ (Finsupp.total P P R id) ((g ∘ₗ i) x) = x
state_after: no goals
tactic: rw [LinearMap.comp_apply, ← LinearMap.comp_apply, hg,
    ← LinearMap.comp_apply, H, LinearMap.id_apply]
Theorem: Cardinal.isUnit_iff
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

Proof steps:
state_before: a b : Cardinal.{u}
n m : ℕ
⊢ IsUnit a ↔ a = 1
state_after: a b : Cardinal.{u}
n m : ℕ
h : IsUnit a
⊢ a = 1
tactic: refine
    ⟨fun h => ?_, by
      rintro rfl
      exact isUnit_one⟩
state_before: a b : Cardinal.{u}
n m : ℕ
h : IsUnit a
⊢ a = 1
state_after: case inl
b : Cardinal.{u}
n m : ℕ
h : IsUnit 0
⊢ 0 = 1

case inr
a b : Cardinal.{u}
n m : ℕ
h : IsUnit a
ha : a ≠ 0
⊢ a = 1
tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case inr
a b : Cardinal.{u}
n m : ℕ
h : IsUnit a
ha : a ≠ 0
⊢ a = 1
state_after: case inr
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
⊢ a = 1
tactic: rw [isUnit_iff_forall_dvd] at h
state_before: case inr
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
⊢ a = 1
state_after: case inr.intro
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
t : Cardinal.{u}
ht : 1 = a * t
⊢ a = 1
tactic: cases' h 1 with t ht
state_before: case inr.intro
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
t : Cardinal.{u}
ht : 1 = a * t
⊢ a = 1
state_after: case inr.intro
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
t : Cardinal.{u}
ht : a = 1 ∧ t = 1
⊢ a = 1

case inr.intro.ha
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
t : Cardinal.{u}
ht : a * t = 1
⊢ 1 ≤ a

case inr.intro.hb
a b : Cardinal.{u}
n m : ℕ
h : ∀ (y : Cardinal.{u}), a ∣ y
ha : a ≠ 0
t : Cardinal.{u}
ht : a * t = 1
⊢ 1 ≤ t
tactic: rw [eq_comm, mul_eq_one_iff'] at ht
Theorem: QuotientAddGroup.eq_iff_sub_mem
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x y : G
⊢ ↑x = ↑y ↔ x / y ∈ N
state_after: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x y : G
⊢ y⁻¹ * x ∈ N ↔ x / y ∈ N
tactic: refine eq_comm.trans (QuotientGroup.eq.trans ?_)
state_before: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x y : G
⊢ y⁻¹ * x ∈ N ↔ x / y ∈ N
state_after: no goals
tactic: rw [nN.mem_comm_iff, div_eq_mul_inv]
Theorem: Fin.map_valEmbedding_Ioc
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ioc a b) = Ioc ↑a ↑b
state_after: no goals
tactic: simp [Ioc_eq_finset_subtype, Finset.fin, Finset.map_map, Ioc_filter_lt_of_lt_right]
Theorem: div_eq_div_iff_div_eq_div
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a b c d : G
⊢ a / b = c / d ↔ a / c = b / d
state_after: no goals
tactic: rw [div_eq_iff_eq_mul, div_mul_eq_mul_div, div_eq_iff_eq_mul', mul_div_assoc]
Theorem: MeasureTheory.UniformIntegrable.ae_eq
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hf : UniformIntegrable f p μ
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
⊢ UniformIntegrable g p μ
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
⊢ UniformIntegrable g p μ
tactic: obtain ⟨hfm, hunif, C, hC⟩ := hf
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
⊢ UniformIntegrable g p μ
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
i : ι
⊢ eLpNorm (g i) p μ ≤ ↑C
tactic: refine ⟨fun i => (hfm i).congr (hfg i), (unifIntegrable_congr_ae hfg).1 hunif, C, fun i => ?_⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
i : ι
⊢ eLpNorm (g i) p μ ≤ ↑C
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
i : ι
⊢ eLpNorm (f i) p μ ≤ ↑C
tactic: rw [← eLpNorm_congr_ae (hfg i)]
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), eLpNorm (f i) p μ ≤ ↑C
i : ι
⊢ eLpNorm (f i) p μ ≤ ↑C
state_after: no goals
tactic: exact hC i
Theorem: Filter.tendsto_pi
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : Type u_3
m : β → (i : ι) → α i
l : Filter β
⊢ Tendsto m l (pi f) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : Type u_3
m : β → (i : ι) → α i
l : Filter β
⊢ (∀ (i : ι), Tendsto (eval i ∘ m) l (f i)) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)
tactic: simp only [pi, tendsto_iInf, tendsto_comap_iff]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : Type u_3
m : β → (i : ι) → α i
l : Filter β
⊢ (∀ (i : ι), Tendsto (eval i ∘ m) l (f i)) ↔ ∀ (i : ι), Tendsto (fun x => m x i) l (f i)
state_after: no goals
tactic: rfl
Theorem: ideal_eq_bot_of_localization
File: Mathlib/RingTheory/LocalProperties.lean

Proof steps:
state_before: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ x ∈ RingHom.ker (algebraMap R (Localization.AtPrime P))
state_after: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ ∃ y ∈ I, (algebraMap R (Localization.AtPrime P)) y = (algebraMap R (Localization.AtPrime P)) x
tactic: rw [RingHom.mem_ker, ← Submodule.mem_bot R, ← h P hP, IsLocalization.mem_coeSubmodule]
state_before: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ ∃ y ∈ I, (algebraMap R (Localization.AtPrime P)) y = (algebraMap R (Localization.AtPrime P)) x
state_after: no goals
tactic: exact ⟨x, hx, rfl⟩