ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Path.reparam_id
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
⊢ γ.reparam id ⋯ ⋯ ⋯ = γ
state_after: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
x✝ : ↑I
⊢ (γ.reparam id ⋯ ⋯ ⋯) x✝ = γ x✝
tactic: ext
state_before: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
x✝ : ↑I
⊢ (γ.reparam id ⋯ ⋯ ⋯) x✝ = γ x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Arrow.inv_left
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝¹ : Category.{v, u} T
f g : Arrow T
sq : f ⟶ g
inst✝ : IsIso sq
⊢ sq.left ≫ (inv sq).left = 𝟙 f.left
state_after: no goals
tactic: rw [← Comma.comp_left, IsIso.hom_inv_id, id_left]
Theorem: Equiv.finsetCongr_refl
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
⊢ (Equiv.refl α).finsetCongr = Equiv.refl (Finset α)
state_after: case H.a
α : Type u_1
β : Type u_2
γ : Type u_3
x✝ : Finset α
a✝ : α
⊢ a✝ ∈ (Equiv.refl α).finsetCongr x✝ ↔ a✝ ∈ (Equiv.refl (Finset α)) x✝
tactic: ext
state_before: case H.a
α : Type u_1
β : Type u_2
γ : Type u_3
x✝ : Finset α
a✝ : α
⊢ a✝ ∈ (Equiv.refl α).finsetCongr x✝ ↔ a✝ ∈ (Equiv.refl (Finset α)) x✝
state_after: no goals
tactic: simp
Theorem: Module.End.finite_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

Proof steps:
state_before: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
⊢ Set.Finite f.HasEigenvalue
state_after: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ Set.Finite f.HasEigenvalue
tactic: have h : minpoly K f ≠ 0 := minpoly.ne_zero (Algebra.IsIntegral.isIntegral (R := K) f)
state_before: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ Set.Finite f.HasEigenvalue
state_after: case h.e'_2
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ f.HasEigenvalue = (minpoly K f).rootSet K
tactic: convert (minpoly K f).rootSet_finite K
state_before: case h.e'_2
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ f.HasEigenvalue = (minpoly K f).rootSet K
state_after: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ μ ∈ f.HasEigenvalue ↔ μ ∈ (minpoly K f).rootSet K
tactic: ext μ
state_before: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ μ ∈ f.HasEigenvalue ↔ μ ∈ (minpoly K f).rootSet K
state_after: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ f.HasEigenvalue μ ↔ μ ∈ (minpoly K f).rootSet K
tactic: change f.HasEigenvalue μ ↔ _
state_before: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ f.HasEigenvalue μ ↔ μ ∈ (minpoly K f).rootSet K
state_after: no goals
tactic: rw [hasEigenvalue_iff_isRoot, mem_rootSet_of_ne h, IsRoot, coe_aeval_eq_eval]
Theorem: SimpleGraph.IsTuranMaximal.le_iff_eq
File: Mathlib/Combinatorics/SimpleGraph/Turan.lean

Proof steps:
state_before: V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
H : SimpleGraph V
hG : G.IsTuranMaximal r
hH : H.CliqueFree (r + 1)
⊢ G ≤ H ↔ G = H
state_after: no goals
tactic: classical exact ⟨fun hGH ↦ edgeFinset_inj.1 <| eq_of_subset_of_card_le
    (edgeFinset_subset_edgeFinset.2 hGH) (hG.2 _ hH), le_of_eq⟩
Theorem: Nat.Ico_pred_singleton
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a✝ b c a : ℕ
h : 0 < a
⊢ Ico (a - 1) a = {a - 1}
state_after: no goals
tactic: rw [← Icc_pred_right _ h, Icc_self]
Theorem: GenContFract.squashSeq_eq_self_of_terminated
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

Proof steps:
state_before: K : Type u_1
n : ℕ
g : GenContFract K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminatedAt_succ_n : s.TerminatedAt (n + 1)
⊢ squashSeq s n = s
state_after: K : Type u_1
n : ℕ
g : GenContFract K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminatedAt_succ_n : s.get? (n + 1) = none
⊢ squashSeq s n = s
tactic: change s.get? (n + 1) = none at terminatedAt_succ_n
state_before: K : Type u_1
n : ℕ
g : GenContFract K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
terminatedAt_succ_n : s.get? (n + 1) = none
⊢ squashSeq s n = s
state_after: no goals
tactic: cases s_nth_eq : s.get? n <;> simp only [*, squashSeq]
Theorem: AlgebraicGeometry.Scheme.presheaf_map_eqToHom_op
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: X : Scheme
U V : X.Opens
i : U = V
⊢ X.presheaf.map (eqToHom i).op = eqToHom ⋯
state_after: no goals
tactic: rw [eqToHom_op, eqToHom_map]
Theorem: Cardinal.ofENat_eq_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
n : ℕ
⊢ ↑m = ↑n ↔ m = ↑n
state_after: no goals
tactic: norm_cast
Theorem: Profinite.NobelingProof.factors_prod_eq_basis_of_ne
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)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
⊢ (List.map (⇑(LocallyConstant.evalMonoidHom y)) (factors C s x)).prod = 0
state_after: case a
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
⊢ 0 ∈ List.map (⇑(LocallyConstant.evalMonoidHom y)) (factors C s x)
tactic: apply List.prod_eq_zero
state_before: case a
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
⊢ 0 ∈ List.map (⇑(LocallyConstant.evalMonoidHom y)) (factors C s x)
state_after: case a
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0
tactic: simp only [List.mem_map]
state_before: case a
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0
state_after: case a.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
a : I
ha : ↑y a ≠ ↑x a
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0
tactic: obtain ⟨a, ha⟩ : ∃ a, y.val a ≠ x.val a := by contrapose! h; ext; apply h
state_before: case a.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
a : I
ha : ↑y a ≠ ↑x a
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0
state_after: case a.intro.false
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
a : I
ha : ↑y a ≠ ↑x a
hx : ↑x a = false
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0

case a.intro.true
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
h : y ≠ x
a : I
ha : ↑y a ≠ ↑x a
hx : ↑x a = true
⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0
tactic: cases hx : x.val a
Theorem: Finset.truncatedInf_union_right
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : a ∉ upperClosure ↑s
ht : a ∈ upperClosure ↑t
⊢ (s ∪ t).truncatedInf a = t.truncatedInf a
state_after: no goals
tactic: rw [union_comm, truncatedInf_union_left ht hs]
Theorem: upperBounds_empty
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 : α
⊢ upperBounds ∅ = univ
state_after: no goals
tactic: simp only [upperBounds, eq_univ_iff_forall, mem_setOf_eq, forall_mem_empty, forall_true_iff]
Theorem: Matrix.sum_elim_dotProduct_sum_elim
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ Sum.elim u x ⬝ᵥ Sum.elim v y = u ⬝ᵥ v + x ⬝ᵥ y
state_after: no goals
tactic: simp [dotProduct]
Theorem: int_prod_range_nonneg
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

Proof steps:
state_before: m : ℤ
n : ℕ
hn : Even n
⊢ 0 ≤ ∏ k ∈ Finset.range n, (m - ↑k)
state_after: case intro
m : ℤ
n : ℕ
⊢ 0 ≤ ∏ k ∈ Finset.range (n + n), (m - ↑k)
tactic: rcases hn with ⟨n, rfl⟩
state_before: case intro
m : ℤ
n : ℕ
⊢ 0 ≤ ∏ k ∈ Finset.range (n + n), (m - ↑k)
state_after: case intro.zero
m : ℤ
⊢ 0 ≤ ∏ k ∈ Finset.range (0 + 0), (m - ↑k)

case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (n + n), (m - ↑k)
⊢ 0 ≤ ∏ k ∈ Finset.range (n + 1 + (n + 1)), (m - ↑k)
tactic: induction' n with n ihn
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (n + n), (m - ↑k)
⊢ 0 ≤ ∏ k ∈ Finset.range (n + 1 + (n + 1)), (m - ↑k)
state_after: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ ∏ k ∈ Finset.range (n + 1 + (n + 1)), (m - ↑k)
tactic: rw [← two_mul] at ihn
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ ∏ k ∈ Finset.range (n + 1 + (n + 1)), (m - ↑k)
state_after: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (∏ x ∈ Finset.range ((1 + 1) * n), (m - ↑x)) * ((m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1)))
tactic: rw [← two_mul, mul_add, mul_one, ← one_add_one_eq_two, ← add_assoc,
    Finset.prod_range_succ, Finset.prod_range_succ, mul_assoc]
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (∏ x ∈ Finset.range ((1 + 1) * n), (m - ↑x)) * ((m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1)))
state_after: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1))
tactic: refine mul_nonneg ihn ?_
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1))
state_after: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
k : ℕ
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))
tactic: generalize (1 + 1) * n = k
state_before: case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
k : ℕ
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))
state_after: case intro.succ.inl
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : m ≤ ↑k
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))

case intro.succ.inr
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
k : ℕ
hmk : ↑k < m
⊢ 0 ≤ (m - ↑k) * (m - ↑(k + 1))
tactic: rcases le_or_lt m k with hmk | hmk
Theorem: Finset.sup_eq_biUnion
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
⊢ s.sup t = s.biUnion t
state_after: case a
F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
a✝ : β
⊢ a✝ ∈ s.sup t ↔ a✝ ∈ s.biUnion t
tactic: ext
state_before: case a
F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
a✝ : β
⊢ a✝ ∈ s.sup t ↔ a✝ ∈ s.biUnion t
state_after: no goals
tactic: rw [mem_sup, mem_biUnion]
Theorem: LinearMap.BilinForm.flip_flip
File: Mathlib/LinearAlgebra/BilinearForm/Basic.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
D : BilinForm R M
D₁ : BilinForm R₁ M₁
⊢ flipHom ≪≫ₗ flipHom = LinearEquiv.refl R (BilinForm R M)
state_after: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
D : BilinForm R M
D₁ : BilinForm R₁ M₁
A : BilinForm R M
x✝ y✝ : M
⊢ (((flipHom ≪≫ₗ flipHom) A) x✝) y✝ = (((LinearEquiv.refl R (BilinForm R M)) A) x✝) y✝
tactic: ext A
state_before: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
D : BilinForm R M
D₁ : BilinForm R₁ M₁
A : BilinForm R M
x✝ y✝ : M
⊢ (((flipHom ≪≫ₗ flipHom) A) x✝) y✝ = (((LinearEquiv.refl R (BilinForm R M)) A) x✝) y✝
state_after: no goals
tactic: simp
Theorem: Function.monotone_iterate_of_id_le
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
h : id ≤ f
n : ℕ
x : α
⊢ f^[n] x ≤ f^[n + 1] x
state_after: α : Type u_1
inst✝ : Preorder α
f : α → α
h : id ≤ f
n : ℕ
x : α
⊢ f^[n] x ≤ f (f^[n] x)
tactic: rw [iterate_succ_apply']
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
h : id ≤ f
n : ℕ
x : α
⊢ f^[n] x ≤ f (f^[n] x)
state_after: no goals
tactic: exact h _
Theorem: finprod_mem_eq_finite_toFinset_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hs : s.Finite
⊢ s ∩ mulSupport f = ↑hs.toFinset ∩ mulSupport f
state_after: no goals
tactic: rw [hs.coe_toFinset]
Theorem: AddCommGroup.DirectLimit.congr_symm_apply_of
File: Mathlib/Algebra/DirectLimit.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g✝ : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) ((f i j hij) x) = (g✝ i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
e : (i : ι) → G i ≃+ G' i
he : ∀ (i j : ι) (h : i ≤ j), (e j).toAddMonoidHom.comp (f i j h) = (f' i j h).comp ↑(e i)
i : ι
g : G' i
⊢ (congr e he).symm ((of G' f' i) g) = (of G f i) ((e i).symm g)
state_after: no goals
tactic: simp only [congr, AddMonoidHom.toAddEquiv_symm_apply, map_apply_of, AddMonoidHom.coe_coe]
Theorem: OreLocalization.numeratorRingHom_apply
File: Mathlib/RingTheory/OreLocalization/Ring.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Semiring R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddCommMonoid X
inst✝ : Module R X
⊢ (↑__spread✝⁻⁰).toFun 0 = 0
state_after: no goals
tactic: with_unfolding_all exact OreLocalization.zero_def
Theorem: MeasureTheory.measure_ne_zero_iff_nonempty_of_isAddLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
hμ : μ ≠ 0
s : Set G
hs : IsOpen s
⊢ μ s ≠ 0 ↔ s.Nonempty
state_after: no goals
tactic: simpa [null_iff_of_isMulLeftInvariant (μ := μ) hs, hμ] using nonempty_iff_ne_empty.symm
Theorem: cfc_comp_zpow
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : Semifield R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : HasContinuousInv₀ R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f✝ : R → R
a✝ : A
inst✝ : UniqueContinuousFunctionalCalculus R A
f : R → R
n : ℤ
a : Aˣ
hf : autoParam (ContinuousOn f ((fun x => x ^ n) '' spectrum R ↑a)) _auto✝
ha : autoParam (p ↑a) _auto✝
⊢ cfc (fun x => f (x ^ n)) ↑a = cfc f ↑(a ^ n)
state_after: no goals
tactic: rw [cfc_comp' .., cfc_zpow a]
Theorem: Mathlib.Meta.Positivity.log_nonneg_of_isNat
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: e : ℝ
d n : ℕ
h : NormNum.IsNat e n
⊢ 0 ≤ Real.log e
state_after: e : ℝ
d n : ℕ
h : NormNum.IsNat e n
⊢ 0 ≤ Real.log ↑n
tactic: rw [NormNum.IsNat.to_eq h rfl]
state_before: e : ℝ
d n : ℕ
h : NormNum.IsNat e n
⊢ 0 ≤ Real.log ↑n
state_after: no goals
tactic: exact Real.log_natCast_nonneg _
Theorem: Profinite.NobelingProof.mem_C'_eq_false
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}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ∀ x ∈ C' C ho, x (term I ho) = false
state_after: case intro.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
y : I → Bool
left✝¹ : y ∈ C1 C ho
left✝ : Proj (fun x => ord I x < o) y ∈ C0 C ho
⊢ Proj (fun x => ord I x < o) y (term I ho) = false
tactic: rintro x ⟨_, y, _, rfl⟩
state_before: case intro.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
y : I → Bool
left✝¹ : y ∈ C1 C ho
left✝ : Proj (fun x => ord I x < o) y ∈ C0 C ho
⊢ Proj (fun x => ord I x < o) y (term I ho) = false
state_after: no goals
tactic: simp only [Proj, ord_term_aux, lt_self_iff_false, ite_false]
Theorem: AkraBazziRecurrence.base_nonempty
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
⊢ (Ico ⌊b (min_bi b) / 2 * ↑n⌋₊ n).Nonempty
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
⊢ (Ico ⌊b (min_bi b) / 2 * ↑n⌋₊ n).Nonempty
tactic: let b' := b (min_bi b)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
⊢ (Ico ⌊b (min_bi b) / 2 * ↑n⌋₊ n).Nonempty
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
hb_pos : 0 < b'
⊢ (Ico ⌊b (min_bi b) / 2 * ↑n⌋₊ n).Nonempty
tactic: have hb_pos : 0 < b' := R.b_pos _
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
hb_pos : 0 < b'
⊢ (Ico ⌊b (min_bi b) / 2 * ↑n⌋₊ n).Nonempty
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
hb_pos : 0 < b'
⊢ ⌊b (min_bi b) / 2 * ↑n⌋₊ < n
tactic: simp_rw [Finset.nonempty_Ico]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
hb_pos : 0 < b'
⊢ ⌊b (min_bi b) / 2 * ↑n⌋₊ < n
state_after: no goals
tactic: exact_mod_cast calc ⌊b' / 2 * n⌋₊ ≤ b' / 2 * n := by exact Nat.floor_le (by positivity)
                                 _ < 1 / 2 * n   := by gcongr; exact R.b_lt_one (min_bi b)
                                 _ ≤ 1 * n       := by gcongr; norm_num
                                 _ = n           := by simp
Theorem: Filter.tendsto_atTop'
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
inst✝¹ : Nonempty α
inst✝ : SemilatticeSup α
f : α → β
l : Filter β
⊢ Tendsto f atTop l ↔ ∀ s ∈ l, ∃ a, ∀ b ≥ a, f b ∈ s
state_after: no goals
tactic: simp only [tendsto_def, mem_atTop_sets, mem_preimage]