ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.map_surjOn_Iic_iff_le_map
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Filter α
G : Filter β
m : α → β
⊢ SurjOn (map m) (Iic F) (Iic G) ↔ G ≤ map m F
state_after: case refine_1
α : Type u_1
β : Type u_2
F : Filter α
G : Filter β
m : α → β
hm : SurjOn (map m) (Iic F) (Iic G)
⊢ G ≤ map m F

case refine_2
α : Type u_1
β : Type u_2
F : Filter α
G : Filter β
m : α → β
hm : G ≤ map m F
⊢ SurjOn (map m) (Iic F) (Iic G)
tactic: refine ⟨fun hm ↦ ?_, fun hm ↦ ?_⟩
Theorem: ENNReal.eventually_pow_one_div_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: x : ℝ≥0∞
hx : x ≠ ⊤
y : ℝ≥0∞
hy : 1 < y
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
state_after: case intro
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y
tactic: lift x to ℝ≥0 using hx
state_before: case intro
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y
state_after: case pos
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
h : y = ⊤
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y

case neg
y : ℝ≥0∞
hy : 1 < y
x : ℝ≥0
h : ¬y = ⊤
⊢ ∀ᶠ (n : ℕ) in atTop, ↑x ^ (1 / ↑n) ≤ y
tactic: by_cases h : y = ∞
Theorem: Polynomial.degree_eq_natDegree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
⊢ p.degree = ↑p.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn : ¬n ∉ p.degree
⊢ p.degree = ↑p.natDegree
tactic: let ⟨n, hn⟩ := not_forall.1 (mt Option.eq_none_iff_forall_not_mem.2 (mt degree_eq_bot.1 hp))
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn : ¬n ∉ p.degree
⊢ p.degree = ↑p.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬n ∉ p.degree
hn : p.degree = Option.some n
⊢ p.degree = ↑p.natDegree
tactic: have hn : degree p = some n := Classical.not_not.1 hn
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬n ∉ p.degree
hn : p.degree = Option.some n
⊢ p.degree = ↑p.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬n ∉ p.degree
hn : p.degree = Option.some n
⊢ Option.some n = ↑(WithBot.unbot' 0 (Option.some n))
tactic: rw [natDegree, hn]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬n ∉ p.degree
hn : p.degree = Option.some n
⊢ Option.some n = ↑(WithBot.unbot' 0 (Option.some n))
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.SignedMeasure.absolutelyContinuous_ennreal_iff
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure
state_after: case mp
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s ≪ᵥ μ
⊢ s.totalVariation ≪ μ.ennrealToMeasure

case mpr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s.totalVariation ≪ μ.ennrealToMeasure
⊢ s ≪ᵥ μ
tactic: constructor <;> intro h
Theorem: IsDedekindDomain.HeightOneSpectrum.valuation_exists_uniformizer
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))
state_after: case intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))
tactic: obtain ⟨r, hr⟩ := v.intValuation_exists_uniformizer
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ ∃ π, v.valuation π = ↑(ofAdd (-1))
state_after: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.valuation ((algebraMap R K) r) = ↑(ofAdd (-1))
tactic: use algebraMap R K r
state_before: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.valuation ((algebraMap R K) r) = ↑(ofAdd (-1))
state_after: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.intValuation r = ↑(ofAdd (-1))
tactic: rw [valuation_def, Valuation.extendToLocalization_apply_map_apply]
state_before: case h
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
hr : v.intValuationDef r = ↑(ofAdd (-1))
⊢ v.intValuation r = ↑(ofAdd (-1))
state_after: no goals
tactic: exact hr
Theorem: IsGLB.insert
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeInf γ
a b : γ
s : Set γ
hs : IsGLB s b
⊢ IsGLB (insert a s) (a ⊓ b)
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeInf γ
a b : γ
s : Set γ
hs : IsGLB s b
⊢ IsGLB ({a} ∪ s) (a ⊓ b)
tactic: rw [insert_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeInf γ
a b : γ
s : Set γ
hs : IsGLB s b
⊢ IsGLB ({a} ∪ s) (a ⊓ b)
state_after: no goals
tactic: exact isGLB_singleton.union hs
Theorem: Filter.atTop_finset_eq_iInf
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ atTop = ⨅ x, 𝓟 (Ici {x})
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ ⨅ x, 𝓟 (Ici {x}) ≤ atTop
tactic: refine le_antisymm (le_iInf fun i => le_principal_iff.2 <| mem_atTop ({i} : Finset α)) ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ ⨅ x, 𝓟 (Ici {x}) ≤ atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ⋂ i, Ici {↑i} ⊆ Ici s
tactic: refine
    le_iInf fun s =>
      le_principal_iff.2 <| mem_iInf_of_iInter s.finite_toSet (fun i => mem_principal_self _) ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ⋂ i, Ici {↑i} ⊆ Ici s
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ∀ (x : Finset α), (∀ x_1 ∈ ↑s, x_1 ∈ x) → ∀ ⦃x_1 : α⦄, x_1 ∈ s → x_1 ∈ x
tactic: simp only [subset_def, mem_iInter, SetCoe.forall, mem_Ici, Finset.le_iff_subset,
    Finset.mem_singleton, Finset.subset_iff, forall_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ∀ (x : Finset α), (∀ x_1 ∈ ↑s, x_1 ∈ x) → ∀ ⦃x_1 : α⦄, x_1 ∈ s → x_1 ∈ x
state_after: no goals
tactic: exact fun t => id
Theorem: Multiset.sum_nsmul
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ (0 • m).prod = m.prod ^ 0
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod 0 = 1
tactic: rw [zero_nsmul, pow_zero]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
⊢ prod 0 = 1
state_after: no goals
tactic: rfl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m✝ : Multiset ι
f g : ι → α
m : Multiset α
n : ℕ
⊢ ((n + 1) • m).prod = m.prod ^ (n + 1)
state_after: no goals
tactic: rw [add_nsmul, one_nsmul, pow_add, pow_one, prod_add, prod_nsmul m n]
Theorem: Basis.ext_multilinear_fin
File: Mathlib/LinearAlgebra/Multilinear/Basis.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
n : ℕ
M : Fin n → Type u_3
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : (i : Fin n) → AddCommMonoid (M i)
inst✝² : (i : Fin n) → Module R (M i)
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f g : MultilinearMap R M M₂
ι₁ : Fin n → Type u_6
e : (i : Fin n) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin n) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g
state_after: case zero
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
M : Fin 0 → Type u_3
inst✝¹ : (i : Fin 0) → AddCommMonoid (M i)
inst✝ : (i : Fin 0) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin 0 → Type u_6
e : (i : Fin 0) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin 0) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g

case succ
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (m + 1) → Type u_3
inst✝¹ : (i : Fin (m + 1)) → AddCommMonoid (M i)
inst✝ : (i : Fin (m + 1)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (m + 1) → Type u_6
e : (i : Fin (m + 1)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (m + 1)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g
tactic: induction' n with m hm
Theorem: Submodule.sup_eq_range
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p q : Submodule R M
x : M
⊢ x ∈ p ⊔ q ↔ x ∈ range (p.subtype.coprod q.subtype)
state_after: no goals
tactic: simp [Submodule.mem_sup, SetLike.exists]
Theorem: Multiset.bind_cons
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g✝ : α → Multiset β
f : α → β
g : α → Multiset β
⊢ (bind 0 fun a => f a ::ₘ g a) = map f 0 + bind 0 g
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g✝ : α → Multiset β
f : α → β
g : α → Multiset β
⊢ ∀ (a : α) (s : Multiset α),
    (s.bind fun a => f a ::ₘ g a) = map f s + s.bind g →
      ((a ::ₘ s).bind fun a => f a ::ₘ g a) = map f (a ::ₘ s) + (a ::ₘ s).bind g
state_after: no goals
tactic: simp (config := { contextual := true }) [add_comm, add_left_comm, add_assoc]
Theorem: Nat.psub'_eq_psub
File: Mathlib/Data/Nat/PSub.lean

Proof steps:
state_before: m n : ℕ
⊢ m.psub' n = m.psub n
state_after: m n : ℕ
⊢ (if n ≤ m then some (m - n) else none) = m.psub n
tactic: rw [psub']
state_before: m n : ℕ
⊢ (if n ≤ m then some (m - n) else none) = m.psub n
state_after: case pos
m n : ℕ
h : n ≤ m
⊢ some (m - n) = m.psub n

case neg
m n : ℕ
h : ¬n ≤ m
⊢ none = m.psub n
tactic: split_ifs with h
Theorem: CategoryTheory.whiskerLeft_app
File: Mathlib/CategoryTheory/Whiskering.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G H : D ⥤ E
α : G ⟶ H
X Y : C
f : X ⟶ Y
⊢ (F ⋙ G).map f ≫ (fun X => α.app (F.obj X)) Y = (fun X => α.app (F.obj X)) X ≫ (F ⋙ H).map f
state_after: no goals
tactic: rw [Functor.comp_map, Functor.comp_map, α.naturality]
Theorem: exists_perfect_nonempty_of_isClosed_of_not_countable
File: Mathlib/Topology/Perfect.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
⊢ ∃ D, Perfect D ∧ D.Nonempty ∧ D ⊆ C
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ ∃ D, Perfect D ∧ D.Nonempty ∧ D ⊆ C
tactic: rcases exists_countable_union_perfect_of_isClosed hclosed with ⟨V, D, Vct, Dperf, VD⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ ∃ D, Perfect D ∧ D.Nonempty ∧ D ⊆ C
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D.Nonempty ∧ D ⊆ C
tactic: refine ⟨D, ⟨Dperf, ?_⟩⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D.Nonempty ∧ D ⊆ C
state_after: case intro.intro.intro.intro.left
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D.Nonempty

case intro.intro.intro.intro.right
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D ⊆ C
tactic: constructor
state_before: case intro.intro.intro.intro.right
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D ⊆ C
state_after: case intro.intro.intro.intro.right
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D ⊆ V ∪ D
tactic: rw [VD]
state_before: case intro.intro.intro.intro.right
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : SecondCountableTopology α
hclosed : IsClosed C
hunc : ¬C.Countable
V D : Set α
Vct : V.Countable
Dperf : Perfect D
VD : C = V ∪ D
⊢ D ⊆ V ∪ D
state_after: no goals
tactic: exact subset_union_right
Theorem: CategoryTheory.Presieve.IsSeparatedFor.isSheafFor
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
t : IsSeparatedFor P R
⊢ (∀ (x : FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t) → IsSheafFor P R
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
t : IsSeparatedFor P R
⊢ (∀ (x : FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t) →
    IsSeparatedFor P R ∧ ∀ (x : FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t
tactic: rw [← isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
t : IsSeparatedFor P R
⊢ (∀ (x : FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t) →
    IsSeparatedFor P R ∧ ∀ (x : FamilyOfElements P R), x.Compatible → ∃ t, x.IsAmalgamation t
state_after: no goals
tactic: exact And.intro t
Theorem: CategoryTheory.Limits.imageSubobject_arrow_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
⊢ factorThruImageSubobject f ≫ (imageSubobject f).arrow = f
state_after: no goals
tactic: simp [factorThruImageSubobject, imageSubobject_arrow]
Theorem: Multiset.map_erase_of_mem
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
x : α
h : x ∈ s
⊢ map f (s.erase x) = (map f s).erase (f x)
state_after: case empty
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x : α
h : x ∈ 0
⊢ map f (erase 0 x) = (map f 0).erase (f x)

case cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
h : x ∈ y ::ₘ s
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
tactic: induction' s using Multiset.induction_on with y s ih
state_before: case cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
h : x ∈ y ::ₘ s
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: case cons.inl
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
y : α
s : Multiset α
ih : y ∈ s → map f (s.erase y) = (map f s).erase (f y)
h : y ∈ y ::ₘ s
⊢ map f ((y ::ₘ s).erase y) = (map f (y ::ₘ s)).erase (f y)

case cons.inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
h : x ∈ y ::ₘ s
hxy : y ≠ x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
tactic: rcases eq_or_ne y x with rfl | hxy
state_before: case cons.inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
h : x ∈ y ::ₘ s
hxy : y ≠ x
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: case cons.inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
hxy : y ≠ x
h : x ∈ s
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
tactic: replace h : x ∈ s := by simpa [hxy.symm] using h
state_before: case cons.inr
α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
x y : α
s : Multiset α
ih : x ∈ s → map f (s.erase x) = (map f s).erase (f x)
hxy : y ≠ x
h : x ∈ s
⊢ map f ((y ::ₘ s).erase x) = (map f (y ::ₘ s)).erase (f x)
state_after: no goals
tactic: rw [s.erase_cons_tail hxy, map_cons, map_cons, ih h, erase_cons_tail_of_mem (mem_map_of_mem f h)]
Theorem: Monoid.minOrder_eq_top
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a : α
⊢ minOrder α = ⊤ ↔ IsTorsionFree α
state_after: no goals
tactic: simp [minOrder, IsTorsionFree]
Theorem: smul_ite_zero
File: Mathlib/Algebra/GroupWithZero/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝² : Zero A
inst✝¹ : SMulZeroClass M A
p : Prop
inst✝ : Decidable p
a : M
b : A
⊢ (a • if p then b else 0) = if p then a • b else 0
state_after: no goals
tactic: split_ifs <;> simp
Theorem: MvPowerSeries.map_monomial
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
S : Type u_3
T : Type u_4
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
n : σ →₀ ℕ
a : R
⊢ (map σ f) ((monomial R n) a) = (monomial S n) (f a)
state_after: no goals
tactic: classical
  ext m
  simp [coeff_monomial, apply_ite f]
Theorem: nsmul_zero
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
⊢ 1 ^ (n + 1) = 1
state_after: no goals
tactic: rw [pow_succ, one_pow, one_mul]
Theorem: SetTheory.PGame.lf_iff_exists_le
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y
state_after: xl xr : Type u
x y : PGame
⊢ ((¬∀ (i : y.LeftMoves), y.moveLeft i ⧏ x) ∨ ¬∀ (j : x.RightMoves), y ⧏ x.moveRight j) ↔
    (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y
tactic: rw [LF, le_iff_forall_lf, not_and_or]
state_before: xl xr : Type u
x y : PGame
⊢ ((¬∀ (i : y.LeftMoves), y.moveLeft i ⧏ x) ∨ ¬∀ (j : x.RightMoves), y ⧏ x.moveRight j) ↔
    (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y
state_after: no goals
tactic: simp
Theorem: isLittleO_abs_log_rpow_rpow_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Icc 0 1
⊢ x ∈ {x | (fun x => ((fun x => log x ^ r) ∘ fun x => x⁻¹) x = (fun x => |log x| ^ r) x) x}
state_after: no goals
tactic: simp [abs_of_nonpos, log_nonpos hx.1 hx.2]
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((fun x => x ^ (-s)) ∘ fun x => x⁻¹) x = (fun x => x ^ s) x
state_after: no goals
tactic: rw [Function.comp_apply, inv_rpow hx.out.le, rpow_neg hx.out.le, inv_inv]
Theorem: one_div_lt_neg_one
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h1 : a < 0
h2 : -1 < a
this : 1 / a < 1 / -1
⊢ 1 / a < -1
state_after: no goals
tactic: rwa [one_div_neg_one_eq_neg_one] at this
Theorem: Finset.finite_toSet_toFinset
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Finset α
⊢ ⋯.toFinset = s
state_after: no goals
tactic: rw [toFinite_toFinset, toFinset_coe]
Theorem: Subgroup.coe_inclusion
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K✝ H K : Subgroup G
h : H ≤ K
a : ↥H
⊢ ↑((inclusion h) a) = ↑a
state_after: case mk
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K✝ H K : Subgroup G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
tactic: cases a
state_before: case mk
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K✝ H K : Subgroup G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
state_after: no goals
tactic: simp only [inclusion, coe_mk, MonoidHom.mk'_apply]
Theorem: Finset.filter_inj'
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s t : Finset α
inst✝ : DecidableEq α
⊢ filter p s = filter q s ↔ ∀ ⦃a : α⦄, a ∈ s → (p a ↔ q a)
state_after: no goals
tactic: simp [ext_iff]