ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsLocalization.integerNormalization_eval₂_eq_zero
File: Mathlib/RingTheory/Localization/Integral.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁴ : CommRing S
inst✝³ : Algebra R S
P : Type u_3
inst✝² : CommRing P
inst✝¹ : IsLocalization M S
R' : Type u_4
inst✝ : CommRing R'
g : S →+* R'
p : S[X]
x : R'
hx : eval₂ g x p = 0
b : ↥M
hb : Polynomial.map (algebraMap R S) (integerNormalization M p) = ↑b • p
⊢ eval₂ g x (Polynomial.map (algebraMap R S) (integerNormalization M p)) = 0
state_after: no goals
tactic: rw [hb, ← IsScalarTower.algebraMap_smul S (b : R) p, eval₂_smul, hx, mul_zero]
Theorem: CategoryTheory.Limits.Sigma.ι_reindex_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ✝ : Type w₃
C : Type u
inst✝² : Category.{v, u} C
γ : Type w'
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ⇑ε)
b : β
⊢ ι f (ε b) ≫ (reindex ε f).inv = ι (f ∘ ⇑ε) b
state_after: no goals
tactic: simp [Iso.comp_inv_eq]
Theorem: HurwitzZeta.oddKernel_def'
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a x : ℝ
⊢ ↑(oddKernel (↑a) x) =
    cexp (-↑π * ↑a ^ 2 * ↑x) *
      (jacobiTheta₂' (↑a * I * ↑x) (I * ↑x) / (2 * ↑π * I) + ↑a * jacobiTheta₂ (↑a * I * ↑x) (I * ↑x))
state_after: no goals
tactic: rw [oddKernel_def, jacobiTheta₂'', ← mul_assoc ↑a I x,
    (by ring : ↑π * I * ↑a ^ 2 * (I * ↑x) = I ^ 2 * ↑π * ↑a ^ 2 * x), I_sq, neg_one_mul]
Theorem: Basis.mk_coord_apply_eq
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
i : ι
⊢ (hli.repr ⟨v i, ⋯⟩) i = 1
state_after: no goals
tactic: simp [hli.repr_eq_single i]
Theorem: PosNum.cast_to_int
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : PosNum
⊢ ↑↑n = ↑n
state_after: no goals
tactic: rw [← to_nat_to_int, Int.cast_natCast, cast_to_nat]
Theorem: AddSubmonoid.val_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: LucasLehmer.Int.natCast_pow_pred
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: b p : ℕ
w : 0 < b
⊢ ↑(b ^ p - 1) = ↑b ^ p - 1
state_after: b p : ℕ
w : 0 < b
this : 1 ≤ b ^ p
⊢ ↑(b ^ p - 1) = ↑b ^ p - 1
tactic: have : 1 ≤ b ^ p := Nat.one_le_pow p b w
state_before: b p : ℕ
w : 0 < b
this : 1 ≤ b ^ p
⊢ ↑(b ^ p - 1) = ↑b ^ p - 1
state_after: no goals
tactic: norm_cast
Theorem: EMetric.ball_prod_same
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
x✝ y✝ z✝ : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
inst✝ : PseudoEMetricSpace β
x : α
y : β
r : ℝ≥0∞
z : α × β
⊢ z ∈ ball x r ×ˢ ball y r ↔ z ∈ ball (x, y) r
state_after: no goals
tactic: simp [Prod.edist_eq]
Theorem: CategoryTheory.Limits.strongEpi_of_strongEpiMonoFactorisation
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi F'.e
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi (F.e ≫ (F.toMonoIsImage.isoExt hF').hom)
tactic: rw [← IsImage.e_isoExt_hom F.toMonoIsImage hF']
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi (F.e ≫ (F.toMonoIsImage.isoExt hF').hom)
state_after: no goals
tactic: apply strongEpi_comp
Theorem: CochainComplex.HomComplex.Cocycle.mk_coe
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m✝ : ℤ
z : Cochain F G n
m : ℤ
hnm : n + 1 = m
h : δ n m z = 0
⊢ z ∈ cocycle F G n
state_after: no goals
tactic: simpa only [mem_iff n m hnm z] using h
Theorem: Topology.IsLower.isTopologicalBasis
File: Mathlib/Topology/Order/LowerUpperTopology.lean

Proof steps:
state_before: α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s : Set α
⊢ IsTopologicalBasis (lowerBasis α)
state_after: case h.e'_3
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s : Set α
⊢ lowerBasis α = (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
tactic: convert isTopologicalBasis_of_subbasis (topology_eq α)
state_before: case h.e'_3
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s : Set α
⊢ lowerBasis α = (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
state_after: case h.e'_3
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s : Set α
⊢ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s} = (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
tactic: simp_rw [lowerBasis, coe_upperClosure, compl_iUnion]
state_before: case h.e'_3
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s : Set α
⊢ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s} = (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
state_after: case h.e'_3.h
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s✝ s : Set α
⊢ s ∈ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s} ↔ s ∈ (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
tactic: ext s
state_before: case h.e'_3.h
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s✝ s : Set α
⊢ s ∈ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s} ↔ s ∈ (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}
state_after: case h.e'_3.h.mp
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s✝ s : Set α
⊢ s ∈ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s} → s ∈ (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}}

case h.e'_3.h.mpr
α : Type u_1
β : ?m.7267
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsLower α
s✝ s : Set α
⊢ s ∈ (fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ {s | ∃ a, (Ici a)ᶜ = s}} → s ∈ {s | ∃ t, t.Finite ∧ ⋂ i ∈ t, (Ici i)ᶜ = s}
tactic: constructor
Theorem: Inducing.isSigmaCompact_iff
File: Mathlib/Topology/Compactness/SigmaCompact.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
f : X → Y
s : Set X
hf : Inducing f
⊢ IsSigmaCompact s ↔ IsSigmaCompact (f '' s)
state_after: case mp
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
f : X → Y
s : Set X
hf : Inducing f
⊢ IsSigmaCompact s → IsSigmaCompact (f '' s)

case mpr
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
f : X → Y
s : Set X
hf : Inducing f
⊢ IsSigmaCompact (f '' s) → IsSigmaCompact s
tactic: constructor
Theorem: WithLp.prod_norm_eq_of_nat
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
this : 0 < p.toReal
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)
tactic: have := p.toReal_pos_iff_ne_top.mpr (ne_of_eq_of_ne h <| ENNReal.natCast_ne_top n)
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
this : 0 < p.toReal
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)
state_after: no goals
tactic: simp only [one_div, h, Real.rpow_natCast, ENNReal.toReal_nat, eq_self_iff_true, Finset.sum_congr,
    prod_norm_eq_add this]
Theorem: Matrix.Pivot.listTransvecRow_get
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
r : ℕ
M : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
i : Fin (listTransvecRow M).length
⊢ (listTransvecRow M).get i =
    transvection (inr ()) (inl (Fin.cast ⋯ i)) (-M (inr ()) (inl (Fin.cast ⋯ i)) / M (inr ()) (inr ()))
state_after: no goals
tactic: simp [listTransvecRow, Fin.cast]
Theorem: Filter.iInf_principal_finite
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
s : Set ι
hs : s.Finite
f : ι → Set α
⊢ ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)
state_after: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
s : Finset ι
⊢ ⨅ i ∈ ↑s, 𝓟 (f i) = 𝓟 (⋂ i ∈ ↑s, f i)
tactic: lift s to Finset ι using hs
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
s : Finset ι
⊢ ⨅ i ∈ ↑s, 𝓟 (f i) = 𝓟 (⋂ i ∈ ↑s, f i)
state_after: no goals
tactic: exact mod_cast iInf_principal_finset s f
Theorem: le_symmDiff_sup_right
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ≤ a ∆ b ⊔ b
state_after: no goals
tactic: convert symmDiff_triangle a b ⊥ <;> rw [symmDiff_bot]
Theorem: Real.logb_lt_iff_lt_rpow_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
⊢ logb b x < y ↔ b ^ y < x
state_after: no goals
tactic: rw [← rpow_lt_rpow_left_iff_of_base_lt_one b_pos b_lt_one, rpow_logb b_pos (b_ne_one b_lt_one) hx]
Theorem: EqualCharZero.PNat.isUnit_natCast
File: Mathlib/Algebra/CharP/MixedCharZero.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ IsUnit ↑↑n
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ Ideal.span {↑↑n} = ⊤
tactic: rw [← Ideal.span_singleton_eq_top]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ Ideal.span {↑↑n} = ⊤
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ¬CharZero (R ⧸ Ideal.span {↑↑n})
tactic: apply not_imp_comm.mp (h.elim (Ideal.span {↑n}))
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
⊢ ¬CharZero (R ⧸ Ideal.span {↑↑n})
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ False
tactic: intro h_char_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ False
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n = ↑0
tactic: apply h_char_zero.cast_injective.ne n.ne_zero
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n = ↑0
state_after: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n ∈ Ideal.span {↑↑n}
tactic: rw [← map_natCast (Ideal.Quotient.mk _), Nat.cast_zero, Ideal.Quotient.eq_zero_iff_mem]
state_before: R : Type u_1
inst✝ : CommRing R
h : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
n : ℕ+
h_char_zero : CharZero (R ⧸ Ideal.span {↑↑n})
⊢ ↑↑n ∈ Ideal.span {↑↑n}
state_after: no goals
tactic: exact Ideal.subset_span (Set.mem_singleton _)
Theorem: injective_zpow_iff_not_isOfFinOrder
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
⊢ (Injective fun n => x ^ n) ↔ ¬IsOfFinOrder x
state_after: case refine_1
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
⊢ (Injective fun n => x ^ n) → ¬IsOfFinOrder x

case refine_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : ¬IsOfFinOrder x
n m : ℤ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
tactic: refine ⟨?_, fun h n m hnm => ?_⟩
state_before: case refine_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : ¬IsOfFinOrder x
n m : ℤ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
state_after: no goals
tactic: rwa [zpow_eq_zpow_iff_modEq, orderOf_eq_zero_iff.2 h, Nat.cast_zero, Int.modEq_zero_iff] at hnm
Theorem: CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ sigmaπ I = π I b
state_after: C : Type u
inst✝³ : Category.{v, u} C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π I.fstSigmaMap I.sndSigmaMap =
    π I b ≫
      (colimit.isoColimitCocone
          {
            cocone :=
              I.multicoforkEquivSigmaCofork.inverse.obj (colimit.cocone (parallelPair I.fstSigmaMap I.sndSigmaMap)),
            isColimit :=
              IsColimit.ofPreservesCoconeInitial I.multicoforkEquivSigmaCofork.inverse
                (colimit.isColimit (parallelPair I.fstSigmaMap I.sndSigmaMap)) }).hom
tactic: rw [sigmaπ, ← Category.assoc, Iso.comp_inv_eq, isoCoequalizer]
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π I.fstSigmaMap I.sndSigmaMap =
    π I b ≫
      (colimit.isoColimitCocone
          {
            cocone :=
              I.multicoforkEquivSigmaCofork.inverse.obj (colimit.cocone (parallelPair I.fstSigmaMap I.sndSigmaMap)),
            isColimit :=
              IsColimit.ofPreservesCoconeInitial I.multicoforkEquivSigmaCofork.inverse
                (colimit.isColimit (parallelPair I.fstSigmaMap I.sndSigmaMap)) }).hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π I.fstSigmaMap I.sndSigmaMap =
    (Multicofork.ofSigmaCofork I (colimit.cocone (parallelPair I.fstSigmaMap I.sndSigmaMap))).π b
tactic: simp only [MultispanIndex.multicoforkEquivSigmaCofork_inverse,
    MultispanIndex.ofSigmaCoforkFunctor_obj, colimit.isoColimitCocone_ι_hom,
    Multicofork.ofSigmaCofork_pt, colimit.cocone_x, Multicofork.π_eq_app_right]
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : MultispanIndex C
inst✝² : HasMulticoequalizer I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.R
⊢ Sigma.ι I.right b ≫ coequalizer.π I.fstSigmaMap I.sndSigmaMap =
    (Multicofork.ofSigmaCofork I (colimit.cocone (parallelPair I.fstSigmaMap I.sndSigmaMap))).π b
state_after: no goals
tactic: rfl
Theorem: Stream'.WSeq.liftRel_cons
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ LiftRel R (cons a s) (cons b t) ↔ R a b ∧ LiftRel R s t
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (cons a s).destruct (cons b t).destruct ↔ R a b ∧ LiftRel R s t
tactic: rw [liftRel_destruct_iff]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (cons a s).destruct (cons b t).destruct ↔ R a b ∧ LiftRel R s t
state_after: no goals
tactic: simp [-liftRel_pure_left, -liftRel_pure_right]
Theorem: MeasureTheory.Measure.bind_apply
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
f : α → Measure β
s : Set β
hs : MeasurableSet s
hf : Measurable f
⊢ (m.bind f) s = ∫⁻ (a : α), (f a) s ∂m
state_after: no goals
tactic: rw [bind, join_apply hs, lintegral_map (measurable_coe hs) hf]
Theorem: _private.Mathlib.CategoryTheory.Adjunction.Basic.0.CategoryTheory.Adjunction.he''
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), (e X' Y) (F.map f ≫ g) = f ≫ (e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ F.map f ≫ (e X Y).symm g = (e X' Y).symm (f ≫ g)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), (e X' Y) (F.map f ≫ g) = f ≫ (e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ f ≫ (e X Y) ((e X Y).symm g) = f ≫ g
tactic: rw [Equiv.eq_symm_apply, he]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), (e X' Y) (F.map f ≫ g) = f ≫ (e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ f ≫ (e X Y) ((e X Y).symm g) = f ≫ g
state_after: no goals
tactic: simp
Theorem: Finset.prod_disjUnion
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = (∏ x ∈ s₁, f x) * ∏ x ∈ s₂, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) (1 * 1) (fun x => f x) (s₁.disjUnion s₂ h)
tactic: refine Eq.trans ?_ (fold_disjUnion h)
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) (1 * 1) (fun x => f x) (s₁.disjUnion s₂ h)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) 1 (fun x => f x) (s₁.disjUnion s₂ h)
tactic: rw [one_mul]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁.disjUnion s₂ h, f x = fold (fun x x_1 => x * x_1) 1 (fun x => f x) (s₁.disjUnion s₂ h)
state_after: no goals
tactic: rfl
Theorem: ContinuousLinearMap.smul_compLpL
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
⊢ compLpL p μ (c • L) = c • compLpL p μ L
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p μ)
⊢ (compLpL p μ (c • L)) f = (c • compLpL p μ L) f
tactic: ext1 f
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
g : E → F
c✝ : ℝ≥0
𝕜 : Type u_5
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : Fact (1 ≤ p)
𝕜' : Type u_6
inst✝³ : NormedRing 𝕜'
inst✝² : Module 𝕜' F
inst✝¹ : BoundedSMul 𝕜' F
inst✝ : SMulCommClass 𝕜 𝕜' F
c : 𝕜'
L : E →L[𝕜] F
f : ↥(Lp E p μ)
⊢ (compLpL p μ (c • L)) f = (c • compLpL p μ L) f
state_after: no goals
tactic: exact smul_compLp c L f
Theorem: Set.toFinset_ssubset
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t✝ : Set α
inst✝ : Fintype ↑s
t : Finset α
⊢ s.toFinset ⊂ t ↔ s ⊂ ↑t
state_after: no goals
tactic: rw [← Finset.coe_ssubset, coe_toFinset]