ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.BohrMollerup.f_add_nat_le
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
⊢ f (↑n + x) ≤ f ↑n + x * log ↑n
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
⊢ f (↑n + x) ≤ f ↑n + x * log ↑n
tactic: have hn' : 0 < (n : ℝ) := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn)
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
⊢ f (↑n + x) ≤ f ↑n + x * log ↑n
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
this : f ↑n + x * log ↑n = (1 - x) * f ↑n + x * f (↑n + 1)
⊢ f (↑n + x) ≤ f ↑n + x * log ↑n
tactic: have : f n + x * log n = (1 - x) * f n + x * f (n + 1) := by rw [hf_feq hn']; ring
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
this : f ↑n + x * log ↑n = (1 - x) * f ↑n + x * f (↑n + 1)
⊢ f (↑n + x) ≤ f ↑n + x * log ↑n
state_after: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
this : f ↑n + x * log ↑n = (1 - x) * f ↑n + x * f (↑n + 1)
⊢ f ((1 - x) * ↑n + x * (↑n + 1)) ≤ (1 - x) * f ↑n + x * f (↑n + 1)
tactic: rw [this, (by ring : (n : ℝ) + x = (1 - x) * n + x * (n + 1))]
state_before: f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hn : n ≠ 0
hx : 0 < x
hx' : x ≤ 1
hn' : 0 < ↑n
this : f ↑n + x * log ↑n = (1 - x) * f ↑n + x * f (↑n + 1)
⊢ f ((1 - x) * ↑n + x * (↑n + 1)) ≤ (1 - x) * f ↑n + x * f (↑n + 1)
state_after: no goals
tactic: simpa only [smul_eq_mul] using
    hf_conv.2 hn' (by linarith : 0 < (n + 1 : ℝ)) (by linarith : 0 ≤ 1 - x) hx.le (by linarith)
Theorem: Fin.card_filter_univ_eq_vector_get_eq_count
File: Mathlib/Data/Fintype/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
inst✝ : DecidableEq α
a : α
v : Vector α n
⊢ (filter (fun i => a = v.get i) univ).card = List.count a v.toList
state_after: case nil
α : Type u_1
β : Type u_2
n : ℕ
inst✝ : DecidableEq α
a : α
⊢ (filter (fun i => a = Vector.nil.get i) univ).card = List.count a Vector.nil.toList

case cons
α : Type u_1
β : Type u_2
n✝ : ℕ
inst✝ : DecidableEq α
a : α
n : ℕ
x : α
xs : Vector α n
hxs : (filter (fun i => a = xs.get i) univ).card = List.count a xs.toList
⊢ (filter (fun i => a = (x ::ᵥ xs).get i) univ).card = List.count a (x ::ᵥ xs).toList
tactic: induction' v with n x xs hxs
Theorem: irreducible_pow_sup
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Field K
T : Type u_4
inst✝¹ : CommRing T
inst✝ : IsDedekindDomain T
I J : Ideal T
hI : I ≠ ⊥
hJ : Irreducible J
n : ℕ
⊢ J ^ n ⊔ I = J ^ min (count J (normalizedFactors I)) n
state_after: no goals
tactic: rw [sup_eq_prod_inf_factors (pow_ne_zero n hJ.ne_zero) hI, min_comm,
    normalizedFactors_of_irreducible_pow hJ, normalize_eq J, replicate_inter, prod_replicate]
Theorem: Finset.offDiag_card
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
this : s.diag.card + s.offDiag.card = s.card * s.card
⊢ s.offDiag.card = s.card * s.card - s.card
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
this : s.card + s.offDiag.card = s.card * s.card
⊢ s.offDiag.card = s.card * s.card - s.card
tactic: rw [s.diag_card] at this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
this : s.card + s.offDiag.card = s.card * s.card
⊢ s.offDiag.card = s.card * s.card - s.card
state_after: no goals
tactic: omega
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ s.diag.card + s.offDiag.card = s.card * s.card
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ (filter (fun a => a.1 = a.2) (s ×ˢ s)).card + (filter (fun a => a.1 ≠ a.2) (s ×ˢ s)).card = (s ×ˢ s).card
tactic: rw [← card_product, diag, offDiag]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ (filter (fun a => a.1 = a.2) (s ×ˢ s)).card + (filter (fun a => a.1 ≠ a.2) (s ×ˢ s)).card = (s ×ˢ s).card
state_after: no goals
tactic: conv_rhs => rw [← filter_card_add_filter_neg_card_eq_card (fun a => a.1 = a.2)]
Theorem: MulAction.orbit.eq_or_disjoint
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ orbit G a = orbit G b ∨ Disjoint (orbit G a) (orbit G b)
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b
tactic: apply (em (Disjoint (orbit G a) (orbit G b))).symm.imp _ id
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b
state_after: no goals
tactic: simp (config := { contextual := true })
    only [Set.not_disjoint_iff, ← orbit_eq_iff, forall_exists_index, and_imp, eq_comm, implies_true]
Theorem: ModuleCat.MonoidalCategory.hexagon_reverse
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Symmetric.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
⊢ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv =
    X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y
state_after: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
⊢ (α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv =
    (α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y
tactic: apply (cancel_epi (α_ X Y Z).hom).1
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
⊢ (α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv =
    (α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y
state_after: case H
R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
⊢ ∀ (x : ↑X) (y : ↑Y) (z : ↑Z),
    ((α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
      ((α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)
tactic: apply TensorProduct.ext_threefold
state_before: case H
R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
⊢ ∀ (x : ↑X) (y : ↑Y) (z : ↑Z),
    ((α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
      ((α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)
state_after: case H
R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
x : ↑X
y : ↑Y
z : ↑Z
⊢ ((α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
    ((α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)
tactic: intro x y z
state_before: case H
R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
x : ↑X
y : ↑Y
z : ↑Z
⊢ ((α_ X Y Z).hom ≫ (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
    ((α_ X Y Z).hom ≫ X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)
state_after: no goals
tactic: rfl
Theorem: Set.Finite.induction_to
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C S0
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
⊢ C S
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C S0
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this : Finite ↑S
⊢ C S
tactic: have : Finite S := Finite.to_subtype h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C S0
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this : Finite ↑S
⊢ C S
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C S0
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
⊢ C S
tactic: have : Finite {T : Set α // T ⊆ S} := Finite.of_equiv (Set S) (Equiv.Set.powerset S).symm
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C ↑⟨S0, hS0⟩
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
⊢ C ↑⟨S, ⋯⟩
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C ↑⟨S0, hS0⟩
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
s : { x // x ⊆ S }
hs : ↑s ≠ ↑⟨S, ⋯⟩
hs' : C ↑s
⊢ ∃ c > s, C ↑c
tactic: refine Finite.to_wellFoundedGT.wf.induction_bot' (fun s hs hs' ↦ ?_) H0
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C ↑⟨S0, hS0⟩
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
s : { x // x ⊆ S }
hs : ↑s ≠ ↑⟨S, ⋯⟩
hs' : C ↑s
⊢ ∃ c > s, C ↑c
state_after: case intro.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C ↑⟨S0, hS0⟩
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
s : { x // x ⊆ S }
hs : ↑s ≠ ↑⟨S, ⋯⟩
hs' : C ↑s
a : α
ha' : C (insert a ↑s)
ha1 : a ∈ S
ha2 : a ∉ ↑s
⊢ ∃ c > s, C ↑c
tactic: obtain ⟨a, ⟨ha1, ha2⟩, ha'⟩ := H1 s (ssubset_of_ne_of_subset hs s.2) hs'
state_before: case intro.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
S0 : Set α
hS0 : S0 ⊆ S
H0 : C ↑⟨S0, hS0⟩
H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)
this✝ : Finite ↑S
this : Finite { T // T ⊆ S }
s : { x // x ⊆ S }
hs : ↑s ≠ ↑⟨S, ⋯⟩
hs' : C ↑s
a : α
ha' : C (insert a ↑s)
ha1 : a ∈ S
ha2 : a ∉ ↑s
⊢ ∃ c > s, C ↑c
state_after: no goals
tactic: exact ⟨⟨insert a s.1, insert_subset ha1 s.2⟩, Set.ssubset_insert ha2, ha'⟩
Theorem: LieHom.idealRange_eq_map
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ f.idealRange = LieIdeal.map f ⊤
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ f.idealRange ↔ m✝ ∈ LieIdeal.map f ⊤
tactic: ext
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ f.idealRange ↔ m✝ ∈ LieIdeal.map f ⊤
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ LieSubmodule.lieSpan R L' ↑(LieSubalgebra.map f ⊤) ↔ m✝ ∈ LieIdeal.map f ⊤
tactic: simp only [idealRange, range_eq_map]
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : L'
⊢ m✝ ∈ LieSubmodule.lieSpan R L' ↑(LieSubalgebra.map f ⊤) ↔ m✝ ∈ LieIdeal.map f ⊤
state_after: no goals
tactic: rfl
Theorem: Nat.image_cast_int_Ioo
File: Mathlib/Data/Nat/Cast/SetInterval.lean

Proof steps:
state_before: a b : ℕ
⊢ (range ⇑castOrderEmbedding).OrdConnected
state_after: no goals
tactic: simp [ordConnected_Ici]
Theorem: LinearMap.trace_eq_sum_trace_restrict_of_eq_biSup
File: Mathlib/Algebra/DirectSum/LinearMap.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : ι → Submodule R M
inst✝¹ : ∀ (i : ι), Module.Finite R ↥(N i)
inst✝ : ∀ (i : ι), Module.Free R ↥(N i)
s : Finset ι
h : CompleteLattice.Independent fun i => N ↑i
f : Module.End R M
hf : ∀ (i : ι), MapsTo ⇑f ↑(N i) ↑(N i)
p : Submodule R M
hp : p = ⨆ i ∈ s, N i
hp' : optParam (MapsTo ⇑f ↑p ↑p) ⋯
⊢ (trace R ↥p) (restrict f hp') = ∑ i ∈ s, (trace R ↥(N i)) (restrict f ⋯)
state_after: no goals
tactic: classical
  let N' : s → Submodule R p := fun i ↦ (N i).comap p.subtype
  replace h : IsInternal N' := hp ▸ isInternal_biSup_submodule_of_independent (s : Set ι) h
  have hf' : ∀ i, MapsTo (restrict f hp') (N' i) (N' i) := fun i x hx' ↦ by simpa using hf i hx'
  let e : (i : s) → N' i ≃ₗ[R] N i := fun ⟨i, hi⟩ ↦ (N i).comapSubtypeEquivOfLe (hp ▸ le_biSup N hi)
  have _i1 : ∀ i, Module.Finite R (N' i) := fun i ↦ Module.Finite.equiv (e i).symm
  have _i2 : ∀ i, Module.Free R (N' i) := fun i ↦ Module.Free.of_equiv (e i).symm
  rw [trace_eq_sum_trace_restrict h hf', ← s.sum_coe_sort]
  have : ∀ i : s, f.restrict (hf i) = (e i).conj ((f.restrict hp').restrict (hf' i)) := fun _ ↦ rfl
  simp [this]
Theorem: Matroid.Indep.closure_eq_setOf_basis_insert
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ M.closure I = {x | M.Basis I (insert x I)}
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
⊢ M.closure I = F
tactic: set F := {x | M.Basis I (insert x I)}
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
⊢ M.closure I = F
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
⊢ M.closure I = F
tactic: have hIF : M.Basis I F := hI.basis_setOf_insert_basis
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
⊢ M.closure I = F
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
hF : M.Flat F
⊢ M.closure I = F
tactic: have hF : M.Flat F := by
    refine ⟨fun J X hJF hJX e heX ↦ show M.Basis _ _ from ?_, hIF.subset_ground⟩
    exact (hIF.basis_of_basis_of_subset_of_subset (hJX.basis_union hJF) hJF.subset
      (hIF.subset.trans subset_union_right)).basis_subset (subset_insert _ _)
      (insert_subset (Or.inl heX) (hIF.subset.trans subset_union_right))
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
hF : M.Flat F
⊢ M.closure I = F
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
hF : M.Flat F
⊢ ∀ t' ∈ {F | M.Flat F ∧ I ∩ M.E ⊆ F}, F ⊆ t'

ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
hF : M.Flat F
⊢ F ∈ {F | M.Flat F ∧ I ∩ M.E ⊆ F}
tactic: rw [subset_antisymm_iff, closure_def, subset_sInter_iff, and_iff_right (sInter_subset_of_mem _)]
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
F : Set α := {x | M.Basis I (insert x I)}
hIF : M.Basis I F
hF : M.Flat F
⊢ F ∈ {F | M.Flat F ∧ I ∩ M.E ⊆ F}
state_after: no goals
tactic: exact ⟨hF, inter_subset_left.trans hIF.subset⟩
Theorem: preNormEDS_four
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS b c d 4 = d
state_after: no goals
tactic: erw [preNormEDS_ofNat, preNormEDS'_four]
Theorem: Matrix.uniformity
File: Mathlib/Topology/UniformSpace/Matrix.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
𝕜 : Type u_3
inst✝ : UniformSpace 𝕜
⊢ 𝓤 (Matrix m n 𝕜) = ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
state_after: m : Type u_1
n : Type u_2
𝕜 : Type u_3
inst✝ : UniformSpace 𝕜
⊢ ⨅ i, Filter.comap (fun a => (a.1 i, a.2 i)) (𝓤 (n → 𝕜)) = ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
tactic: erw [Pi.uniformity]
state_before: m : Type u_1
n : Type u_2
𝕜 : Type u_3
inst✝ : UniformSpace 𝕜
⊢ ⨅ i, Filter.comap (fun a => (a.1 i, a.2 i)) (𝓤 (n → 𝕜)) = ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
state_after: m : Type u_1
n : Type u_2
𝕜 : Type u_3
inst✝ : UniformSpace 𝕜
⊢ ⨅ i, ⨅ i_1, Filter.comap ((fun a => (a.1 i_1, a.2 i_1)) ∘ fun a => (a.1 i, a.2 i)) (𝓤 𝕜) =
    ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
tactic: simp_rw [Pi.uniformity, Filter.comap_iInf, Filter.comap_comap]
state_before: m : Type u_1
n : Type u_2
𝕜 : Type u_3
inst✝ : UniformSpace 𝕜
⊢ ⨅ i, ⨅ i_1, Filter.comap ((fun a => (a.1 i_1, a.2 i_1)) ∘ fun a => (a.1 i, a.2 i)) (𝓤 𝕜) =
    ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
state_after: no goals
tactic: rfl
Theorem: antivaryOn_iff_forall_smul_nonpos
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ MonovaryOn f (⇑OrderDual.toDual ∘ g) s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → (f j - f i) • (g j - g i) ≤ 0
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ (∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → (f j - f i) • (g j - g i) ≤ 0
tactic: rw [monovaryOn_iff_forall_smul_nonneg]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ (∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → (f j - f i) • (g j - g i) ≤ 0
state_after: no goals
tactic: rfl
Theorem: IsCyclotomicExtension.Rat.Three.eta_sq_add_eta_add_one
File: Mathlib/NumberTheory/Cyclotomic/Three.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
u : (𝓞 K)ˣ
x : 𝓞 K
⊢ ↑η ^ 2 + ↑η + 1 = 0
state_after: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
u : (𝓞 K)ˣ
x : 𝓞 K
⊢ -↑η - 1 + ↑η + 1 = 0
tactic: rw [eta_sq]
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
u : (𝓞 K)ˣ
x : 𝓞 K
⊢ -↑η - 1 + ↑η + 1 = 0
state_after: no goals
tactic: ring
Theorem: irreducible_iff_prime_of_exists_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
⊢ Irreducible p ↔ Prime p
state_after: case pos
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : p = 0
⊢ Irreducible p ↔ Prime p

case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
⊢ Irreducible p ↔ Prime p
tactic: by_cases hp0 : p = 0
state_before: case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
⊢ Irreducible p ↔ Prime p
state_after: case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
⊢ Prime p
tactic: refine ⟨fun h => ?_, Prime.irreducible⟩
state_before: case neg
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
⊢ Prime p
state_after: case neg.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
f : Multiset α
hf : (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ p
⊢ Prime p
tactic: obtain ⟨f, hf⟩ := pf p hp0
state_before: case neg.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
f : Multiset α
hf : (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ p
⊢ Prime p
state_after: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ b ∈ {q}, Prime b) ∧ {q}.prod ~ᵤ p
⊢ Prime p
tactic: obtain ⟨q, hq, rfl⟩ := prime_factors_irreducible h hf
state_before: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ b ∈ {q}, Prime b) ∧ {q}.prod ~ᵤ p
⊢ Prime p
state_after: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ b ∈ {q}, Prime b) ∧ {q}.prod ~ᵤ p
⊢ Prime q
tactic: rw [hq.prime_iff]
state_before: case neg.intro.intro.intro
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
pf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
p : α
hp0 : ¬p = 0
h : Irreducible p
q : α
hq : p ~ᵤ q
hf : (∀ b ∈ {q}, Prime b) ∧ {q}.prod ~ᵤ p
⊢ Prime q
state_after: no goals
tactic: exact hf.1 q (Multiset.mem_singleton_self _)