ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Equivalence.unop_inverse
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
      (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X) =
    𝟙 (e.functor.unop.obj X)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
tactic: dsimp
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
state_after: no goals
tactic: simp
Theorem: IsAddUnit.add_sub_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a * (b / a) = b
state_after: no goals
tactic: rw [mul_comm, h.div_mul_cancel]
Theorem: CategoryTheory.Limits.Bicone.ofColimitCocone_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Cocone (Discrete.functor f)
ht : IsColimit t
j j' : J
⊢ (fun j => t.ι.app { as := j }) j ≫
      (fun j => ht.desc (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom ⋯ else 0)) j' =
    if h : j = j' then eqToHom ⋯ else 0
state_after: no goals
tactic: simp
Theorem: UpperHalfPlane.ModularGroup.SL_neg_smul
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

Proof steps:
state_before: g✝ : SL(2, ℤ)
z✝ : ℍ
Γ : Subgroup SL(2, ℤ)
g : SL(2, ℤ)
z : ℍ
⊢ -g • z = g • z
state_after: no goals
tactic: simp only [coe_GLPos_neg, sl_moeb, coe_int_neg, neg_smul, coe']
Theorem: BoxIntegral.IntegrationParams.hasBasis_toFilter
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
⊢ (l.toFilter I).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r => {π | ∃ c, l.MemBaseSet I c (r c) π}
state_after: no goals
tactic: simpa only [setOf_exists] using hasBasis_iSup (l.hasBasis_toFilterDistortion I)
Theorem: HasFTaylorSeriesUpTo.continuous
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
⊢ Continuous f
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p univ
⊢ Continuous f
tactic: rw [← hasFTaylorSeriesUpToOn_univ_iff] at h
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p univ
⊢ Continuous f
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p univ
⊢ ContinuousOn f univ
tactic: rw [continuous_iff_continuousOn_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p univ
⊢ ContinuousOn f univ
state_after: no goals
tactic: exact h.continuousOn
Theorem: eq_zero_iff_eq_zero_of_add_eq_zero
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M✝ : Type u_4
M : Type u
inst✝ : MulOneClass M
a b : M
h : a * b = 1
⊢ a = 1 ↔ b = 1
state_after: no goals
tactic: constructor <;> (rintro rfl; simpa using h)
Theorem: Finsupp.update_eq_sub_add_single
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a : α
b : G
⊢ f.update a b = f - single a (f a) + single a b
state_after: no goals
tactic: rw [update_eq_erase_add_single, erase_eq_sub_single]
Theorem: CategoryTheory.Limits.MonoCoprod.binaryCofan_inr
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
⊢ Mono c.inr
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
hc' : IsColimit (BinaryCofan.mk c.inr c.inl)
⊢ Mono c.inr
tactic: haveI hc' : IsColimit (BinaryCofan.mk c.inr c.inl) :=
    BinaryCofan.IsColimit.mk _ (fun f₁ f₂ => hc.desc (BinaryCofan.mk f₂ f₁))
      (by aesop_cat) (by aesop_cat)
      (fun f₁ f₂ m h₁ h₂ => BinaryCofan.IsColimit.hom_ext hc (by aesop_cat) (by aesop_cat))
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
hc' : IsColimit (BinaryCofan.mk c.inr c.inl)
⊢ Mono c.inr
state_after: no goals
tactic: exact binaryCofan_inl _ hc'
Theorem: Finsupp.mem_splitSupport_iff_nonzero
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ i ∈ l.splitSupport ↔ l.split i ≠ 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ (∃ a ∈ l.support, a.fst = i) ↔
    ∃ x,
      x ∈ { support := l.support.preimage (Sigma.mk i) ⋯, toFun := fun a => l ⟨i, a⟩, mem_support_toFun := ⋯ }.support
tactic: rw [splitSupport, @mem_image _ _ (Classical.decEq _), Ne, ← support_eq_empty, ← Ne, ←
    Finset.nonempty_iff_ne_empty, split, comapDomain, Finset.Nonempty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
⊢ (∃ a ∈ l.support, a.fst = i) ↔
    ∃ x,
      x ∈ { support := l.support.preimage (Sigma.mk i) ⋯, toFun := fun a => l ⟨i, a⟩, mem_support_toFun := ⋯ }.support
state_after: no goals
tactic: simp only [exists_prop, Finset.mem_preimage, exists_and_right, exists_eq_right, mem_support_iff,
    Sigma.exists, Ne]
Theorem: Set.encard_diff_add_encard_inter
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s \ t).encard + (s ∩ t).encard = s.encard
state_after: no goals
tactic: rw [← encard_union_eq (disjoint_of_subset_right inter_subset_right disjoint_sdiff_left),
    diff_union_inter]
Theorem: NonUnitalStarAlgebra.toNonUnitalSubalgebra_bot
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
⊢ ⊥.toNonUnitalSubalgebra = ⊥
state_after: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
x : A
⊢ x ∈ ⊥.toNonUnitalSubalgebra ↔ x ∈ ⊥
tactic: ext x
state_before: case h
F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
x : A
⊢ x ∈ ⊥.toNonUnitalSubalgebra ↔ x ∈ ⊥
state_after: no goals
tactic: simp only [mem_bot, NonUnitalStarSubalgebra.mem_toNonUnitalSubalgebra, NonUnitalAlgebra.mem_bot]
Theorem: IsCompact.mem_inf_nhdsSet_of_forall
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t K : Set X
l : Filter X
s : Set X
hK : IsCompact K
hs : ∀ y ∈ K, s ∈ l ⊓ 𝓝 y
⊢ s ∈ ⨆ x ∈ K, l ⊓ 𝓝 x
state_after: no goals
tactic: simpa using hs
Theorem: Function.Periodic.sub_const
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : AddCommGroup α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x - a)) c
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h.add_const (-a)
Theorem: AddSubgroup.relindex_ker
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ f.ker.relindex K = Nat.card ↑(⇑f '' ↑K)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)
tactic: rw [← MonoidHom.comap_bot, relindex_comap, relindex_bot_left]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)
state_after: no goals
tactic: rfl
Theorem: iSup₂_inf_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a✝ b : α
f : (i : ι) → κ i → α
a : α
⊢ (⨆ i, ⨆ j, f i j) ⊓ a = ⨆ i, ⨆ j, f i j ⊓ a
state_after: no goals
tactic: simp only [iSup_inf_eq]
Theorem: MulEquiv.isField
File: Mathlib/Algebra/Field/Equiv.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝¹ : Semiring A
inst✝ : Semiring B
hB : IsField B
e : A ≃* B
x y : A
⊢ e (x * y) = e (y * x)
state_after: no goals
tactic: rw [map_mul, map_mul, hB.mul_comm]
state_before: A : Type u_1
B : Type u_2
inst✝¹ : Semiring A
inst✝ : Semiring B
hB : IsField B
e : A ≃* B
a✝ : A
h : a✝ ≠ 0
⊢ ∃ b, a✝ * b = 1
state_after: case intro
A : Type u_1
B : Type u_2
inst✝¹ : Semiring A
inst✝ : Semiring B
hB : IsField B
e : A ≃* B
a✝ : A
h : a✝ ≠ 0
a' : B
he : e a✝ * a' = 1
⊢ ∃ b, a✝ * b = 1
tactic: obtain ⟨a', he⟩ := hB.mul_inv_cancel ((e.injective.ne h).trans_eq <| map_zero e)
state_before: case intro
A : Type u_1
B : Type u_2
inst✝¹ : Semiring A
inst✝ : Semiring B
hB : IsField B
e : A ≃* B
a✝ : A
h : a✝ ≠ 0
a' : B
he : e a✝ * a' = 1
⊢ ∃ b, a✝ * b = 1
state_after: no goals
tactic: exact ⟨e.symm a', e.injective <| by rw [map_mul, map_one, e.apply_symm_apply, he]⟩
Theorem: Finsupp.mem_span_range_iff_exists_finsupp
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v✝ : α → M
v' : α' → M'
v : α → M
x : M
⊢ x ∈ span R (Set.range v) ↔ ∃ c, (c.sum fun i a => a • v i) = x
state_after: no goals
tactic: simp only [← Finsupp.range_total, LinearMap.mem_range, Finsupp.total_apply]
Theorem: CoxeterSystem.isReduced_reverse
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.IsReduced ω.reverse ↔ cs.IsReduced ω
state_after: no goals
tactic: simp [IsReduced]
Theorem: IsPrimitiveRoot.autToPow_eq_ModularCyclotomicCharacter
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

Proof steps:
state_before: L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (autToPow R hμ) g = (ModularCyclotomicCharacter L ⋯) ↑g
state_after: case a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ ↑((autToPow R hμ) g) = ↑((ModularCyclotomicCharacter L ⋯) ↑g)
tactic: ext
state_before: case a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ ↑((autToPow R hμ) g) = ↑((ModularCyclotomicCharacter L ⋯) ↑g)
state_after: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (↑((autToPow R hμ) g)).val = (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
tactic: apply ZMod.val_injective
state_before: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (↑((autToPow R hμ) g)).val = (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
state_after: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ μ ^ (↑((autToPow R hμ) g)).val = μ ^ (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
tactic: apply hμ.pow_inj (ZMod.val_lt _) (ZMod.val_lt _)
state_before: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ μ ^ (↑((autToPow R hμ) g)).val = μ ^ (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
state_after: no goals
tactic: simpa [autToPow_spec R hμ g, ModularCyclotomicCharacter', ModularCyclotomicCharacter,
    ZMod.ringEquivCongr_val] using ModularCyclotomicCharacter.toFun_spec'' g hμ
Theorem: Fintype.sum_ite_eq_ite_exists
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 : α✝ → β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝³ : Fintype ι
inst✝² : Fintype κ
inst✝¹ : CommMonoid α
p : ι → Prop
inst✝ : DecidablePred p
h : ∀ (i j : ι), p i → p j → i = j
a : α
⊢ (∏ i : ι, if p i then a else 1) = if ∃ i, p i then a else 1
state_after: no goals
tactic: simp [prod_ite_one univ p (by simpa using h)]
Theorem: Finset.sigma_preimage_mk
File: Mathlib/Data/Finset/Preimage.lean

Proof steps:
state_before: α : Type u
β✝ : Type v
ι : Sort w
γ : Type x
β : α → Type u_1
inst✝ : DecidableEq α
s : Finset ((a : α) × β a)
t : Finset α
⊢ (t.sigma fun a => s.preimage (Sigma.mk a) ⋯) = filter (fun a => a.fst ∈ t) s
state_after: case a
α : Type u
β✝ : Type v
ι : Sort w
γ : Type x
β : α → Type u_1
inst✝ : DecidableEq α
s : Finset ((a : α) × β a)
t : Finset α
x : (i : α) × β i
⊢ (x ∈ t.sigma fun a => s.preimage (Sigma.mk a) ⋯) ↔ x ∈ filter (fun a => a.fst ∈ t) s
tactic: ext x
state_before: case a
α : Type u
β✝ : Type v
ι : Sort w
γ : Type x
β : α → Type u_1
inst✝ : DecidableEq α
s : Finset ((a : α) × β a)
t : Finset α
x : (i : α) × β i
⊢ (x ∈ t.sigma fun a => s.preimage (Sigma.mk a) ⋯) ↔ x ∈ filter (fun a => a.fst ∈ t) s
state_after: no goals
tactic: simp [and_comm]
Theorem: Turing.TM0.step_supports
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
⊢ ∀ {c c' : Cfg₀}, c' ∈ step M c → c.q ∈ S → c'.q ∈ S
state_after: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
c' : Cfg₀
h₁ : c' ∈ step M { q := q, Tape := T }
h₂ : { q := q, Tape := T }.q ∈ S
⊢ c'.q ∈ S
tactic: intro ⟨q, T⟩ c' h₁ h₂
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
c' : Cfg₀
h₁ : c' ∈ step M { q := q, Tape := T }
h₂ : { q := q, Tape := T }.q ∈ S
⊢ c'.q ∈ S
state_after: case intro.mk.intro
Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
h₂ : { q := q, Tape := T }.q ∈ S
q' : Λ
a : Stmt₀
h : M q T.head = some (q', a)
h₁ :
  (match (q', a) with
    | (q', a) =>
      { q := q',
        Tape :=
          match a with
          | Stmt.move d => Tape.move d T
          | Stmt.write a => Tape.write a T }) ∈
    step M { q := q, Tape := T }
⊢ (match (q', a) with
      | (q', a) =>
        { q := q',
          Tape :=
            match a with
            | Stmt.move d => Tape.move d T
            | Stmt.write a => Tape.write a T }).q ∈
    S
tactic: rcases Option.map_eq_some'.1 h₁ with ⟨⟨q', a⟩, h, rfl⟩
state_before: case intro.mk.intro
Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
S : Set Λ
ss : Supports M S
q : Λ
T : Tape Γ
h₂ : { q := q, Tape := T }.q ∈ S
q' : Λ
a : Stmt₀
h : M q T.head = some (q', a)
h₁ :
  (match (q', a) with
    | (q', a) =>
      { q := q',
        Tape :=
          match a with
          | Stmt.move d => Tape.move d T
          | Stmt.write a => Tape.write a T }) ∈
    step M { q := q, Tape := T }
⊢ (match (q', a) with
      | (q', a) =>
        { q := q',
          Tape :=
            match a with
            | Stmt.move d => Tape.move d T
            | Stmt.write a => Tape.write a T }).q ∈
    S
state_after: no goals
tactic: exact ss.2 h h₂
Theorem: Submodule.mem_iSup_of_directed
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁵ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R₂ M₂
F : Type u_8
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
inst✝ : Nonempty ι
S : ι → Submodule R M
H : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ iSup S ↔ ∃ i, x ∈ S i
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁵ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R₂ M₂
F : Type u_8
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
inst✝ : Nonempty ι
S : ι → Submodule R M
H : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ (∃ i, x ∈ ↑(S i)) ↔ ∃ i, x ∈ S i
tactic: rw [← SetLike.mem_coe, coe_iSup_of_directed S H, mem_iUnion]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁵ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R₂ M₂
F : Type u_8
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
ι : Sort u_9
inst✝ : Nonempty ι
S : ι → Submodule R M
H : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ (∃ i, x ∈ ↑(S i)) ↔ ∃ i, x ∈ S i
state_after: no goals
tactic: rfl
Theorem: Equiv.trans_refl
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ e.trans (Equiv.refl β) = e
state_after: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (Equiv.refl β) =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
tactic: cases e
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (Equiv.refl β) =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
state_after: no goals
tactic: rfl
Theorem: Polynomial.normUnit_content
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ normUnit p.content = 1
state_after: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : p.content = 0
⊢ normUnit p.content = 1

case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ normUnit p.content = 1
tactic: by_cases hp0 : p.content = 0