ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Affine.Simplex.sum_reflectionCircumcenterWeightsWithCircumcenter
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 1)
h : i₁ ≠ i₂
⊢ ∑ i : PointsWithCircumcenterIndex n, reflectionCircumcenterWeightsWithCircumcenter i₁ i₂ i = 1
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 1)
h : i₁ ≠ i₂
⊢ ((if i₁ ∈ univ then {i₁} else ∅) ∪ if i₂ ∈ univ then {i₂} else ∅).card • 1 +
        (filter (fun x => ¬(x = i₁ ∨ x = i₂)) univ).card • 0 +
      -1 =
    1
tactic: simp_rw [sum_pointsWithCircumcenter, reflectionCircumcenterWeightsWithCircumcenter, sum_ite,
    sum_const, filter_or, filter_eq']
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 1)
h : i₁ ≠ i₂
⊢ ((if i₁ ∈ univ then {i₁} else ∅) ∪ if i₂ ∈ univ then {i₂} else ∅).card • 1 +
        (filter (fun x => ¬(x = i₁ ∨ x = i₂)) univ).card • 0 +
      -1 =
    1
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 1)
h : i₁ ≠ i₂
⊢ ((if i₁ ∈ univ then {i₁} else ∅).card + (if i₂ ∈ univ then {i₂} else ∅).card) • 1 +
        (filter (fun x => ¬(x = i₁ ∨ x = i₂)) univ).card • 0 +
      -1 =
    1

V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 1)
h : i₁ ≠ i₂
⊢ Disjoint (if i₁ ∈ univ then {i₁} else ∅) (if i₂ ∈ univ then {i₂} else ∅)
tactic: rw [card_union_of_disjoint]
Theorem: Finset.not_mem_sdiff_of_not_mem_left
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∉ s
⊢ a ∉ s \ t
state_after: no goals
tactic: simp [h]
Theorem: MulAction.orbitRel.Quotient.orbit_nonempty
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
⊢ x.orbit.Nonempty
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
⊢ (MulAction.orbit G (Quotient.out' x)).Nonempty
tactic: rw [orbitRel.Quotient.orbit_eq_orbit_out x Quotient.out_eq']
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
⊢ (MulAction.orbit G (Quotient.out' x)).Nonempty
state_after: no goals
tactic: exact orbit_nonempty _
Theorem: unitInterval.continuous_symm
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: ⊢ Continuous σ
state_after: no goals
tactic: apply Continuous.subtype_mk (by fun_prop)
Theorem: rank_closureCommutatorRepresentatives_le
File: Mathlib/GroupTheory/Abelianization.lean

Proof steps:
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank ↥(closureCommutatorRepresentatives G) ≤ 2 * Nat.card ↑(commutatorSet G)
state_after: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank ↥(closureCommutatorRepresentatives G) ≤ Nat.card ↑(commutatorSet G) + Nat.card ↑(commutatorSet G)
tactic: rw [two_mul]
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank ↥(closureCommutatorRepresentatives G) ≤ Nat.card ↑(commutatorSet G) + Nat.card ↑(commutatorSet G)
state_after: no goals
tactic: exact
    (Subgroup.rank_closure_finite_le_nat_card _).trans
      ((Set.card_union_le _ _).trans
        (add_le_add ((Finite.card_image_le _).trans (Finite.card_range_le _))
          ((Finite.card_image_le _).trans (Finite.card_range_le _))))
Theorem: Equiv.Perm.sigmaCongrRightHom_injective
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : α → Type u_2
⊢ Function.Injective ⇑(sigmaCongrRightHom β)
state_after: α✝ : Type u
β✝ : Type v
α : Type u_1
β : α → Type u_2
x y : (a : α) → Perm (β a)
h : (sigmaCongrRightHom β) x = (sigmaCongrRightHom β) y
⊢ x = y
tactic: intro x y h
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : α → Type u_2
x y : (a : α) → Perm (β a)
h : (sigmaCongrRightHom β) x = (sigmaCongrRightHom β) y
⊢ x = y
state_after: case h.H
α✝ : Type u
β✝ : Type v
α : Type u_1
β : α → Type u_2
x y : (a : α) → Perm (β a)
h : (sigmaCongrRightHom β) x = (sigmaCongrRightHom β) y
a : α
b : β a
⊢ (x a) b = (y a) b
tactic: ext a b
state_before: case h.H
α✝ : Type u
β✝ : Type v
α : Type u_1
β : α → Type u_2
x y : (a : α) → Perm (β a)
h : (sigmaCongrRightHom β) x = (sigmaCongrRightHom β) y
a : α
b : β a
⊢ (x a) b = (y a) b
state_after: no goals
tactic: simpa using Equiv.congr_fun h ⟨a, b⟩
Theorem: EReal.natCast_mul
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: m n : ℕ
⊢ ↑(m * n) = ↑m * ↑n
state_after: no goals
tactic: rw [← coe_coe_eq_natCast, ← coe_coe_eq_natCast, ← coe_coe_eq_natCast, Nat.cast_mul, EReal.coe_mul]
Theorem: List.cons_bagInter_of_neg
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ l₂
⊢ (a :: l₁).bagInter l₂ = l₁.bagInter l₂
state_after: case nil
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ []
⊢ (a :: l₁).bagInter [] = l₁.bagInter []

case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : ¬a ∈ head✝ :: tail✝
⊢ (a :: l₁).bagInter (head✝ :: tail✝) = l₁.bagInter (head✝ :: tail✝)
tactic: cases l₂
state_before: case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : ¬a ∈ head✝ :: tail✝
⊢ (a :: l₁).bagInter (head✝ :: tail✝) = l₁.bagInter (head✝ :: tail✝)
state_after: no goals
tactic: simp only [erase_of_not_mem h, List.bagInter, if_neg (mt mem_of_elem_eq_true h)]
Theorem: convexHull_diam
File: Mathlib/Analysis/Convex/Normed.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s✝ t s : Set E
⊢ diam ((convexHull ℝ) s) = diam s
state_after: no goals
tactic: simp only [Metric.diam, convexHull_ediam]
Theorem: Set.Countable.exists_pos_forall_sum_le
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∀ (t : Finset ι), ↑t ⊆ s → ∑ i ∈ t, ε' i ≤ ε
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∀ (t : Finset ι), ↑t ⊆ s → ∑ i ∈ t, ε' i ≤ ε
tactic: rcases hs.exists_pos_hasSum_le hε with ⟨ε', hpos, c, hε'c, hcε⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∀ (t : Finset ι), ↑t ⊆ s → ∑ i ∈ t, ε' i ≤ ε
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ i ∈ t, ε' i ≤ ε
tactic: refine ⟨ε', hpos, fun t ht ↦ ?_⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ i ∈ t, ε' i ≤ ε
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ x ∈ Finset.subtype (fun x => x ∈ s) t, ε' ↑x ≤ ε
tactic: rw [← sum_subtype_of_mem _ ht]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∑ x ∈ Finset.subtype (fun x => x ∈ s) t, ε' ↑x ≤ ε
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∀ i ∉ Finset.subtype (fun x => x ∈ s) t, 0 ≤ ε' ↑i
tactic: refine (sum_le_hasSum _ ?_ hε'c).trans hcε
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ι : Type u_4
s : Set ι
hs : s.Countable
ε : ℝ
hε : 0 < ε
ε' : ι → ℝ
hpos : ∀ (i : ι), 0 < ε' i
c : ℝ
hε'c : HasSum (fun i => ε' ↑i) c
hcε : c ≤ ε
t : Finset ι
ht : ↑t ⊆ s
⊢ ∀ i ∉ Finset.subtype (fun x => x ∈ s) t, 0 ≤ ε' ↑i
state_after: no goals
tactic: exact fun _ _ ↦ (hpos _).le
Theorem: Profinite.NobelingProof.GoodProducts.linearIndependent_iff_union_smaller
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o✝ : Ordinal.{u}
ho✝ : o✝.IsLimit
hsC✝ : contained C o✝
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
⊢ LinearIndependent ℤ (eval C) ↔ LinearIndependent ℤ fun (p : ↑(⋃ e, smaller C ↑e)) => ↑p
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o✝ : Ordinal.{u}
ho✝ : o✝.IsLimit
hsC✝ : contained C o✝
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
⊢ LinearIndependent (ι := ↑(range C)) ℤ ((fun p => ↑p) ∘ (range_equiv C ho hsC).toFun) ↔
    LinearIndependent ℤ fun (p : ↑(⋃ e, smaller C ↑e)) => ↑p
tactic: rw [GoodProducts.linearIndependent_iff_range, ← range_equiv_factorization C ho hsC]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o✝ : Ordinal.{u}
ho✝ : o✝.IsLimit
hsC✝ : contained C o✝
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
⊢ LinearIndependent (ι := ↑(range C)) ℤ ((fun p => ↑p) ∘ (range_equiv C ho hsC).toFun) ↔
    LinearIndependent ℤ fun (p : ↑(⋃ e, smaller C ↑e)) => ↑p
state_after: no goals
tactic: exact linearIndependent_equiv (range_equiv C ho hsC)
Theorem: CategoryTheory.regularTopology.equalizerCondition_w'
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.33373, u_2} D
inst✝¹ : Category.{?u.33377, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : HasPullback π π
⊢ P.map π.op ≫ P.map (pullback.fst π π).op = P.map π.op ≫ P.map (pullback.snd π π).op
state_after: no goals
tactic: simp only [← Functor.map_comp, ← op_comp, pullback.condition]
Theorem: Ordnode.Valid'.balance
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : ∃ l' r', BalancedSz l' r' ∧ (l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l')
⊢ Valid' o₁ (l.balance x r) o₂
state_after: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : ∃ l' r', BalancedSz l' r' ∧ (l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l')
⊢ Valid' o₁ (l.balance' x r) o₂
tactic: rw [balance_eq_balance' hl.3 hr.3 hl.2 hr.2]
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : ∃ l' r', BalancedSz l' r' ∧ (l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l')
⊢ Valid' o₁ (l.balance' x r) o₂
state_after: no goals
tactic: exact hl.balance' hr H
Theorem: EReal.toReal_le_toReal
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
h : x ≤ y
hx : x ≠ ⊥
hy : y ≠ ⊤
⊢ x.toReal ≤ y.toReal
state_after: case intro
y : EReal
hy : y ≠ ⊤
x : ℝ
h : ↑x ≤ y
hx : ↑x ≠ ⊥
⊢ (↑x).toReal ≤ y.toReal
tactic: lift x to ℝ using ⟨ne_top_of_le_ne_top hy h, hx⟩
state_before: case intro
y : EReal
hy : y ≠ ⊤
x : ℝ
h : ↑x ≤ y
hx : ↑x ≠ ⊥
⊢ (↑x).toReal ≤ y.toReal
state_after: case intro.intro
x : ℝ
hx : ↑x ≠ ⊥
y : ℝ
hy : ↑y ≠ ⊤
h : ↑x ≤ ↑y
⊢ (↑x).toReal ≤ (↑y).toReal
tactic: lift y to ℝ using ⟨hy, ne_bot_of_le_ne_bot hx h⟩
state_before: case intro.intro
x : ℝ
hx : ↑x ≠ ⊥
y : ℝ
hy : ↑y ≠ ⊤
h : ↑x ≤ ↑y
⊢ (↑x).toReal ≤ (↑y).toReal
state_after: no goals
tactic: simpa using h
Theorem: isNoetherian_of_fg_of_noetherian
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
⊢ IsNoetherian R ↥N
state_after: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
⊢ IsNoetherian R ↥N
tactic: let ⟨s, hs⟩ := hN
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
⊢ IsNoetherian R ↥N
state_after: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this : DecidableEq M
⊢ IsNoetherian R ↥N
tactic: haveI := Classical.decEq M
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this : DecidableEq M
⊢ IsNoetherian R ↥N
state_after: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝ : DecidableEq M
this : DecidableEq R
⊢ IsNoetherian R ↥N
tactic: haveI := Classical.decEq R
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝ : DecidableEq M
this : DecidableEq R
⊢ IsNoetherian R ↥N
state_after: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝¹ : DecidableEq M
this✝ : DecidableEq R
this : ∀ x ∈ s, x ∈ N
⊢ IsNoetherian R ↥N
tactic: have : ∀ x ∈ s, x ∈ N := fun x hx => hs ▸ Submodule.subset_span hx
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝¹ : DecidableEq M
this✝ : DecidableEq R
this : ∀ x ∈ s, x ∈ N
⊢ IsNoetherian R ↥N
state_after: case refine_1
R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝¹ : DecidableEq M
this✝ : DecidableEq R
this : ∀ x ∈ s, x ∈ N
⊢ (↑↑s → R) →ₗ[R] ↥N

case refine_2
R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N : Submodule R M
I : IsNoetherianRing R
hN : N.FG
s : Finset M
hs : span R ↑s = N
this✝¹ : DecidableEq M
this✝ : DecidableEq R
this : ∀ x ∈ s, x ∈ N
⊢ LinearMap.range ?refine_1 = ⊤
tactic: refine
    @isNoetherian_of_surjective
      R ((↑s : Set M) → R) N _ _ _ (Pi.module _ _ _) _ ?_ ?_ isNoetherian_pi
Theorem: Inducing.multipliable_iff_tprod_comp_mem_range
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : CommMonoid α
inst✝⁵ : TopologicalSpace α
f✝ g✝ : β → α
a b : α
s : Finset β
inst✝⁴ : CommMonoid γ
inst✝³ : TopologicalSpace γ
inst✝² : T2Space γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
⊢ Multipliable f ↔ Multipliable (⇑g ∘ f) ∧ ∏' (i : β), g (f i) ∈ Set.range ⇑g
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : CommMonoid α
inst✝⁵ : TopologicalSpace α
f✝ g✝ : β → α
a b : α
s : Finset β
inst✝⁴ : CommMonoid γ
inst✝³ : TopologicalSpace γ
inst✝² : T2Space γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
⊢ Multipliable f → Multipliable (⇑g ∘ f) ∧ ∏' (i : β), g (f i) ∈ Set.range ⇑g

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁶ : CommMonoid α
inst✝⁵ : TopologicalSpace α
f✝ g✝ : β → α
a b : α
s : Finset β
inst✝⁴ : CommMonoid γ
inst✝³ : TopologicalSpace γ
inst✝² : T2Space γ
G : Type u_5
inst✝¹ : FunLike G α γ
inst✝ : MonoidHomClass G α γ
g : G
hg : Inducing ⇑g
f : β → α
⊢ Multipliable (⇑g ∘ f) ∧ ∏' (i : β), g (f i) ∈ Set.range ⇑g → Multipliable f
tactic: constructor
Theorem: Finset.disjSum_eq_empty
File: Mathlib/Data/Finset/Sum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Finset α
t : Finset β
s₁ s₂ : Finset α
t₁ t₂ : Finset β
a : α
b : β
x : α ⊕ β
⊢ s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅
state_after: no goals
tactic: simp [ext_iff]
Theorem: Behrend.norm_of_mem_sphere
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x)‖ = √↑k
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x) i‖ ^ 2) = √↑k
tactic: rw [EuclideanSpace.norm_eq]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x) i‖ ^ 2) = √↑k
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, |↑(x i)| ^ 2) = √↑k
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, |↑(x i)| ^ 2) = √↑k
state_after: no goals
tactic: simp_rw [abs_cast, ← cast_pow, ← cast_sum, (mem_filter.1 hx).2]
Theorem: Ideal.comap_lt_comap_of_integral_mem_sdiff
File: Mathlib/RingTheory/Ideal/Over.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
f : R →+* S
I J : Ideal S
inst✝ : Algebra R S
hI : I.IsPrime
hIJ : I ≤ J
x : S
mem : x ∈ ↑J \ ↑I
integral : IsIntegral R x
⊢ comap (algebraMap R S) I < comap (algebraMap R S) J
state_after: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
f : R →+* S
I J : Ideal S
inst✝ : Algebra R S
hI : I.IsPrime
hIJ : I ≤ J
x : S
mem : x ∈ ↑J \ ↑I
p : R[X]
p_monic : p.Monic
hpx : eval₂ (algebraMap R S) x p = 0
⊢ comap (algebraMap R S) I < comap (algebraMap R S) J
tactic: obtain ⟨p, p_monic, hpx⟩ := integral
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
f : R →+* S
I J : Ideal S
inst✝ : Algebra R S
hI : I.IsPrime
hIJ : I ≤ J
x : S
mem : x ∈ ↑J \ ↑I
p : R[X]
p_monic : p.Monic
hpx : eval₂ (algebraMap R S) x p = 0
⊢ comap (algebraMap R S) I < comap (algebraMap R S) J
state_after: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
f : R →+* S
I J : Ideal S
inst✝ : Algebra R S
hI : I.IsPrime
hIJ : I ≤ J
x : S
mem : x ∈ ↑J \ ↑I
p : R[X]
p_monic : p.Monic
hpx : eval₂ (algebraMap R S) x p = 0
⊢ eval₂ (algebraMap R S) x p ∈ I
tactic: refine comap_lt_comap_of_root_mem_sdiff hIJ mem (map_monic_ne_zero p_monic) ?_
state_before: case intro.intro
R : Type u_1
inst✝² : CommRing R
S : Type u_2
inst✝¹ : CommRing S
f : R →+* S
I J : Ideal S
inst✝ : Algebra R S
hI : I.IsPrime
hIJ : I ≤ J
x : S
mem : x ∈ ↑J \ ↑I
p : R[X]
p_monic : p.Monic
hpx : eval₂ (algebraMap R S) x p = 0
⊢ eval₂ (algebraMap R S) x p ∈ I
state_after: no goals
tactic: convert I.zero_mem
Theorem: _private.Mathlib.GroupTheory.Perm.Basic.0.Equiv.Perm.inv_aux
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
p : α → Prop
f : Perm α
⊢ (∀ (x : α), p (f⁻¹ x) ↔ p (f (f⁻¹ x))) ↔ ∀ (x : α), p x ↔ p (f⁻¹ x)
state_after: no goals
tactic: simp_rw [f.apply_inv_self, Iff.comm]
Theorem: UpperHalfPlane.dist_self_center
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

Proof steps:
state_before: z✝ w : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
⊢ dist ↑z ↑(z.center r) = z.im * (Real.cosh r - 1)
state_after: z✝ w : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
⊢ |(↑(z.center r)).im - (↑z).im| = z.im * Real.cosh r - z.im
tactic: rw [dist_of_re_eq (z.center_re r).symm, dist_comm, Real.dist_eq, mul_sub, mul_one]
state_before: z✝ w : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
⊢ |(↑(z.center r)).im - (↑z).im| = z.im * Real.cosh r - z.im
state_after: no goals
tactic: exact abs_of_nonneg (sub_nonneg.2 <| le_mul_of_one_le_right z.im_pos.le (one_le_cosh _))
Theorem: CategoryTheory.Equalizer.Presieve.compatible_iff
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
x : FirstObj P R
⊢ ((firstObjEqFamily P R).hom x).Compatible ↔ firstMap P R x = secondMap P R x
state_after: C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
x : FirstObj P R
⊢ ((firstObjEqFamily P R).hom x).PullbackCompatible ↔ firstMap P R x = secondMap P R x
tactic: rw [Presieve.pullbackCompatible_iff]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
x : FirstObj P R
⊢ ((firstObjEqFamily P R).hom x).PullbackCompatible ↔ firstMap P R x = secondMap P R x
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
x : FirstObj P R
⊢ ((firstObjEqFamily P R).hom x).PullbackCompatible → firstMap P R x = secondMap P R x

case mpr
C : Type u
inst✝¹ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
inst✝ : R.hasPullbacks
x : FirstObj P R
⊢ firstMap P R x = secondMap P R x → ((firstObjEqFamily P R).hom x).PullbackCompatible
tactic: constructor
Theorem: CategoryTheory.Grothendieck.id_base
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.4689, u_1} C
inst✝ : Category.{?u.4693, u_2} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (𝟙 X.base)).obj X.fiber = X.fiber
state_after: no goals
tactic: erw [CategoryTheory.Functor.map_id, Functor.id_obj X.fiber]
Theorem: Polynomial.roots_list_prod
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : 0 ∉ hd :: tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : ¬0 = hd ∧ 0 ∉ tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots
tactic: rw [List.mem_cons, not_or] at H
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : ¬0 = hd ∧ 0 ∉ tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots
state_after: no goals
tactic: rw [List.prod_cons, roots_mul (mul_ne_zero (Ne.symm H.1) <| List.prod_ne_zero H.2), ←
      Multiset.cons_coe, Multiset.cons_bind, ih H.2]