ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsPrimitiveRoot.toInteger_isPrimitiveRoot
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k✝ : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
k : ℕ+
hζ : IsPrimitiveRoot ζ ↑k
⊢ IsPrimitiveRoot ((algebraMap (𝓞 K) K) hζ.toInteger) ↑k
state_after: no goals
tactic: exact hζ
Theorem: DenseRange.prod_map
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
ι : Type u_5
κ : Type u_6
f : ι → Y
g : κ → Z
hf : DenseRange f
hg : DenseRange g
⊢ DenseRange (Prod.map f g)
state_after: no goals
tactic: simpa only [DenseRange, prod_range_range_eq] using hf.prod hg
Theorem: NumberField.mixedEmbedding.norm_eq_zero_iff'
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ Set.range ⇑(mixedEmbedding K)
⊢ mixedEmbedding.norm x = 0 ↔ x = 0
state_after: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a : K
⊢ mixedEmbedding.norm ((mixedEmbedding K) a) = 0 ↔ (mixedEmbedding K) a = 0
tactic: obtain ⟨a, rfl⟩ := hx
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a : K
⊢ mixedEmbedding.norm ((mixedEmbedding K) a) = 0 ↔ (mixedEmbedding K) a = 0
state_after: no goals
tactic: rw [norm_eq_norm, Rat.cast_abs, abs_eq_zero, Rat.cast_eq_zero, Algebra.norm_eq_zero_iff,
    map_eq_zero]
Theorem: Submodule.comap_fst
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ comap (fst R M M₂) p = p.prod ⊤
state_after: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (fst R M M₂) p ↔ (x, y) ∈ p.prod ⊤
tactic: ext ⟨x, y⟩
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (fst R M M₂) p ↔ (x, y) ∈ p.prod ⊤
state_after: no goals
tactic: simp
Theorem: Matroid.sum_indep_iff
File: Mathlib/Data/Matroid/Sum.lean

Proof steps:
state_before: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
I : Set (α ⊕ β)
⊢ (M.sum N).Indep I ↔ M.Indep (Sum.inl ⁻¹' I) ∧ N.Indep (Sum.inr ⁻¹' I)
state_after: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
I : Set (α ⊕ β)
⊢ M.Indep
        ((fun a => a.down) ''
          (Sigma.mk false ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' I)))) ∧
      N.Indep
        ((fun a => a.down) ''
          (Sigma.mk true ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' I)))) ↔
    M.Indep (Sum.inl ⁻¹' I) ∧ N.Indep (Sum.inr ⁻¹' I)
tactic: simp only [Matroid.sum, mapEquiv_indep_iff, Equiv.sumCongr_symm, Equiv.sumCongr_apply,
    Equiv.symm_symm, sigma_indep_iff, Bool.forall_bool, Equiv.ulift_apply]
state_before: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
I : Set (α ⊕ β)
⊢ M.Indep
        ((fun a => a.down) ''
          (Sigma.mk false ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' I)))) ∧
      N.Indep
        ((fun a => a.down) ''
          (Sigma.mk true ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' I)))) ↔
    M.Indep (Sum.inl ⁻¹' I) ∧ N.Indep (Sum.inr ⁻¹' I)
state_after: no goals
tactic: convert Iff.rfl <;>
    simp [Set.ext_iff, Equiv.ulift, Equiv.sumEquivSigmaBool]
Theorem: WittVector.wittMul_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittMul p 0 = X (0, 0) * X (1, 0)
state_after: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittMul p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) * X (1, 0))
tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittMul p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) * X (1, 0))
state_after: no goals
tactic: simp only [wittMul, wittStructureRat, rename_X, xInTermsOfW_zero, map_X, wittPolynomial_zero,
    map_mul, bind₁_X_right, map_wittStructureInt]
Theorem: BooleanRing.inf_sup_self
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a * (a + b + a * b) = a
state_after: no goals
tactic: rw [mul_add, mul_add, mul_self, ← mul_assoc, mul_self, add_assoc, add_self, add_zero]
Theorem: CategoryTheory.Functor.map_shiftFunctorCompIsoId_inv_app
File: Mathlib/CategoryTheory/Shift/CommShift.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{u_6, u_1} C
inst✝⁹ : Category.{u_7, u_2} D
inst✝⁸ : Category.{?u.89019, u_3} E
F : C ⥤ D
G : D ⥤ E
A : Type u_4
B : Type u_5
inst✝⁷ : AddMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : HasShift C A
inst✝⁴ : HasShift D A
inst✝³ : HasShift E A
inst✝² : HasShift C B
inst✝¹ : HasShift D B
inst✝ : F.CommShift A
X : C
a b : A
h : a + b = 0
⊢ F.map ((shiftFunctorCompIsoId C a b h).inv.app X) =
    (shiftFunctorCompIsoId D a b h).inv.app (F.obj X) ≫
      (shiftFunctor D b).map ((F.commShiftIso a).inv.app X) ≫ (F.commShiftIso b).inv.app ((shiftFunctor C a).obj X)
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{u_6, u_1} C
inst✝⁹ : Category.{u_7, u_2} D
inst✝⁸ : Category.{?u.89019, u_3} E
F : C ⥤ D
G : D ⥤ E
A : Type u_4
B : Type u_5
inst✝⁷ : AddMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : HasShift C A
inst✝⁴ : HasShift D A
inst✝³ : HasShift E A
inst✝² : HasShift C B
inst✝¹ : HasShift D B
inst✝ : F.CommShift A
X : C
a b : A
h : a + b = 0
⊢ 𝟙 (F.obj ((shiftFunctor C a ⋙ shiftFunctor C b).obj X)) =
    ((F.commShiftIso b).hom.app ((shiftFunctor C a).obj X) ≫
        (shiftFunctor D b).map ((F.commShiftIso a).hom.app X) ≫ (shiftFunctorCompIsoId D a b h).hom.app (F.obj X)) ≫
      (shiftFunctorCompIsoId D a b h).inv.app (F.obj X) ≫
        (shiftFunctor D b).map ((F.commShiftIso a).inv.app X) ≫ (F.commShiftIso b).inv.app ((shiftFunctor C a).obj X)
tactic: rw [← cancel_epi (F.map ((shiftFunctorCompIsoId C a b h).hom.app X)), ← F.map_comp,
    Iso.hom_inv_id_app, F.map_id, map_shiftFunctorCompIsoId_hom_app]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{u_6, u_1} C
inst✝⁹ : Category.{u_7, u_2} D
inst✝⁸ : Category.{?u.89019, u_3} E
F : C ⥤ D
G : D ⥤ E
A : Type u_4
B : Type u_5
inst✝⁷ : AddMonoid A
inst✝⁶ : AddCommMonoid B
inst✝⁵ : HasShift C A
inst✝⁴ : HasShift D A
inst✝³ : HasShift E A
inst✝² : HasShift C B
inst✝¹ : HasShift D B
inst✝ : F.CommShift A
X : C
a b : A
h : a + b = 0
⊢ 𝟙 (F.obj ((shiftFunctor C a ⋙ shiftFunctor C b).obj X)) =
    ((F.commShiftIso b).hom.app ((shiftFunctor C a).obj X) ≫
        (shiftFunctor D b).map ((F.commShiftIso a).hom.app X) ≫ (shiftFunctorCompIsoId D a b h).hom.app (F.obj X)) ≫
      (shiftFunctorCompIsoId D a b h).inv.app (F.obj X) ≫
        (shiftFunctor D b).map ((F.commShiftIso a).inv.app X) ≫ (F.commShiftIso b).inv.app ((shiftFunctor C a).obj X)
state_after: no goals
tactic: simp only [comp_obj, id_obj, Category.assoc, Iso.hom_inv_id_app_assoc,
    ← Functor.map_comp_assoc, Iso.hom_inv_id_app, Functor.map_id, Category.id_comp]
Theorem: mul_nonpos_iff_neg_imp_nonneg
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Ring α
inst✝⁴ : LinearOrder α
a b : α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a * b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)
state_after: α : Type u
β : Type u_1
inst✝⁵ : Ring α
inst✝⁴ : LinearOrder α
a b : α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ (0 < -a → 0 ≤ b) ∧ (0 < b → 0 ≤ -a) ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)
tactic: rw [← neg_nonneg, ← neg_mul, mul_nonneg_iff_pos_imp_nonneg (α := α)]
state_before: α : Type u
β : Type u_1
inst✝⁵ : Ring α
inst✝⁴ : LinearOrder α
a b : α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ (0 < -a → 0 ≤ b) ∧ (0 < b → 0 ≤ -a) ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)
state_after: no goals
tactic: simp only [neg_pos, neg_nonneg]
Theorem: Filter.HasBasis.congr
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p'✝ : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : l.HasBasis p s
p' : ι → Prop
s' : ι → Set α
hp : ∀ (i : ι), p i ↔ p' i
hs : ∀ (i : ι), p i → s i = s' i
t : Set α
⊢ t ∈ l ↔ ∃ i, p' i ∧ s' i ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p'✝ : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : l.HasBasis p s
p' : ι → Prop
s' : ι → Set α
hp : ∀ (i : ι), p i ↔ p' i
hs : ∀ (i : ι), p i → s i = s' i
t : Set α
⊢ (∃ i, p i ∧ s i ⊆ t) ↔ ∃ i, p i ∧ s' i ⊆ t
tactic: simp only [hl.mem_iff, ← hp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p'✝ : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : l.HasBasis p s
p' : ι → Prop
s' : ι → Set α
hp : ∀ (i : ι), p i ↔ p' i
hs : ∀ (i : ι), p i → s i = s' i
t : Set α
⊢ (∃ i, p i ∧ s i ⊆ t) ↔ ∃ i, p i ∧ s' i ⊆ t
state_after: no goals
tactic: exact exists_congr fun i ↦
    and_congr_right fun hi ↦ hs i hi ▸ Iff.rfl
Theorem: CategoryTheory.GradedObject.hom_ext
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
⊢ f = g
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
x✝ : β
⊢ f x✝ = g x✝
tactic: funext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
β : Type u_1
X Y : GradedObject β C
f g : X ⟶ Y
h : ∀ (x : β), f x = g x
x✝ : β
⊢ f x✝ = g x✝
state_after: no goals
tactic: apply h
Theorem: Equiv.Perm.IsCycleOn.isCycle_subtypePerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ (f.subtypePerm ⋯).IsCycle
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a✝ b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
a : α
ha : a ∈ s
⊢ (f.subtypePerm ⋯).IsCycle
tactic: obtain ⟨a, ha⟩ := hs.nonempty
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a✝ b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
a : α
ha : a ∈ s
⊢ (f.subtypePerm ⋯).IsCycle
state_after: no goals
tactic: exact
    ⟨⟨a, ha⟩, ne_of_apply_ne ((↑) : s → α) (hf.apply_ne hs ha), fun b _ =>
      (hf.2 (⟨a, ha⟩ : s).2 b.2).subtypePerm⟩
Theorem: CategoryTheory.Over.CreatesConnected.raiseCone_pt
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Connected.lean

Proof steps:
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
    ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y =
      (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
state_after: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
      (fun j => homMk (c.π.app j) ⋯) Y =
    (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
tactic: intro X Y f
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
      (fun j => homMk (c.π.app j) ⋯) Y =
    (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
state_after: case left
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y).left =
    ((fun j => homMk (c.π.app j) ⋯) X ≫ F.map f).left

case right
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y).right =
    ((fun j => homMk (c.π.app j) ⋯) X ≫ F.map f).right
tactic: apply CommaMorphism.ext
Theorem: Matrix.trace_eq_sum_roots_charpoly_of_splits
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Eigs.lean

Proof steps:
state_before: n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type u_2
inst✝ : Field R
A : Matrix n n R
hAps : Splits (RingHom.id R) A.charpoly
⊢ A.trace = A.charpoly.roots.sum
state_after: case inl
n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type u_2
inst✝ : Field R
A : Matrix n n R
hAps : Splits (RingHom.id R) A.charpoly
h : IsEmpty n
⊢ A.trace = A.charpoly.roots.sum

case inr
n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type u_2
inst✝ : Field R
A : Matrix n n R
hAps : Splits (RingHom.id R) A.charpoly
h✝ : Nonempty n
⊢ A.trace = A.charpoly.roots.sum
tactic: cases' isEmpty_or_nonempty n with h
Theorem: CategoryTheory.Functor.preimageIso_hom
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.4319, u_1} E
X✝ Y✝ : C
F : C ⥤ D
X Y Z : C
inst✝¹ : F.Full
inst✝ : F.Faithful
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.hom ≫ F.preimage f.inv) = F.map (𝟙 X)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.4319, u_1} E
X✝ Y✝ : C
F : C ⥤ D
X Y Z : C
inst✝¹ : F.Full
inst✝ : F.Faithful
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.inv ≫ F.preimage f.hom) = F.map (𝟙 Y)
state_after: no goals
tactic: simp
Theorem: Subgroup.closure_induction'
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ p x hx
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ ∃ (x_1 : x ∈ closure k), p x x_1
tactic: refine Exists.elim ?_ fun (hx : x ∈ closure k) (hc : p x hx) => hc
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
p : (x : G) → x ∈ closure k → Prop
mem : ∀ (x : G) (h : x ∈ k), p x ⋯
one : p 1 ⋯
mul : ∀ (x : G) (hx : x ∈ closure k) (y : G) (hy : y ∈ closure k), p x hx → p y hy → p (x * y) ⋯
inv : ∀ (x : G) (hx : x ∈ closure k), p x hx → p x⁻¹ ⋯
x : G
hx : x ∈ closure k
⊢ ∃ (x_1 : x ∈ closure k), p x x_1
state_after: no goals
tactic: exact
    closure_induction hx (fun x hx => ⟨_, mem x hx⟩) ⟨_, one⟩
      (fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ => ⟨_, mul _ _ _ _ hx hy⟩) fun x ⟨hx', hx⟩ => ⟨_, inv _ _ hx⟩
Theorem: HurwitzZeta.oddKernel_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
x : ℝ
⊢ oddKernel (-a) x = -oddKernel a x
state_after: case H
x a' : ℝ
⊢ oddKernel (-↑a') x = -oddKernel (↑a') x
tactic: induction' a using QuotientAddGroup.induction_on' with a'
state_before: case H
x a' : ℝ
⊢ oddKernel (-↑a') x = -oddKernel (↑a') x
state_after: no goals
tactic: rw [← ofReal_inj, ← QuotientAddGroup.mk_neg, oddKernel_def, ofReal_neg, ofReal_neg, oddKernel_def,
    jacobiTheta₂''_neg_left]
Theorem: SetTheory.Game.add_lf_add_right
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: ⊢ ∀ {b c : Game}, b ⧏ c → ∀ (a : Game), b + a ⧏ c + a
state_after: case mk.mk.mk
b✝ : Game
b : PGame
c✝ : Game
c : PGame
h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c
a✝ : Game
a : PGame
⊢ Quot.mk Setoid.r b + Quot.mk Setoid.r a ⧏ Quot.mk Setoid.r c + Quot.mk Setoid.r a
tactic: rintro ⟨b⟩ ⟨c⟩ h ⟨a⟩
state_before: case mk.mk.mk
b✝ : Game
b : PGame
c✝ : Game
c : PGame
h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c
a✝ : Game
a : PGame
⊢ Quot.mk Setoid.r b + Quot.mk Setoid.r a ⧏ Quot.mk Setoid.r c + Quot.mk Setoid.r a
state_after: no goals
tactic: apply PGame.add_lf_add_right h
Theorem: CategoryTheory.Limits.BinaryFan.leftUnitor_hom
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y X : C
s : Cone (Functor.empty C)
P : IsLimit s
t : BinaryFan s.pt X
Q : IsLimit t
⊢ t.snd ≫
      Q.lift
        (mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
          (𝟙 { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt)) =
    𝟙 t.pt
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y X : C
s : Cone (Functor.empty C)
P : IsLimit s
t : BinaryFan s.pt X
Q : IsLimit t
⊢ ∀ (j : Discrete WalkingPair),
    (t.snd ≫
          Q.lift
            (mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
              (𝟙 { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt))) ≫
        t.π.app j =
      𝟙 t.pt ≫ t.π.app j
tactic: apply Q.hom_ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y X : C
s : Cone (Functor.empty C)
P : IsLimit s
t : BinaryFan s.pt X
Q : IsLimit t
⊢ ∀ (j : Discrete WalkingPair),
    (t.snd ≫
          Q.lift
            (mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
              (𝟙 { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt))) ≫
        t.π.app j =
      𝟙 t.pt ≫ t.π.app j
state_after: case mk.left
C : Type u
inst✝ : Category.{v, u} C
X✝ Y X : C
s : Cone (Functor.empty C)
P : IsLimit s
t : BinaryFan s.pt X
Q : IsLimit t
⊢ (t.snd ≫
        Q.lift
          (mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
            (𝟙 { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt))) ≫
      t.π.app { as := WalkingPair.left } =
    𝟙 t.pt ≫ t.π.app { as := WalkingPair.left }

case mk.right
C : Type u
inst✝ : Category.{v, u} C
X✝ Y X : C
s : Cone (Functor.empty C)
P : IsLimit s
t : BinaryFan s.pt X
Q : IsLimit t
⊢ (t.snd ≫
        Q.lift
          (mk (P.lift { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } })
            (𝟙 { pt := X, π := { app := fun x => x.as.elim, naturality := ⋯ } }.pt))) ≫
      t.π.app { as := WalkingPair.right } =
    𝟙 t.pt ≫ t.π.app { as := WalkingPair.right }
tactic: rintro ⟨⟨⟩⟩
Theorem: MeasureTheory.Measure.rnDeriv_add_of_mutuallySingular
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
⊢ (ν₁ + ν₂).rnDeriv μ =ᶠ[ae μ] ν₁.rnDeriv μ
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
x : α
hx_add : (ν₁ + ν₂).rnDeriv μ x = (ν₁.rnDeriv μ + ν₂.rnDeriv μ) x
hx_zero : ν₂.rnDeriv μ x = 0 x
⊢ (ν₁ + ν₂).rnDeriv μ x = ν₁.rnDeriv μ x
tactic: filter_upwards [rnDeriv_add' ν₁ ν₂ μ, (rnDeriv_eq_zero ν₂ μ).mpr h] with x hx_add hx_zero
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν ν₁ ν₂ μ : Measure α
inst✝² : SigmaFinite ν₁
inst✝¹ : SigmaFinite ν₂
inst✝ : SigmaFinite μ
h : ν₂ ⟂ₘ μ
x : α
hx_add : (ν₁ + ν₂).rnDeriv μ x = (ν₁.rnDeriv μ + ν₂.rnDeriv μ) x
hx_zero : ν₂.rnDeriv μ x = 0 x
⊢ (ν₁ + ν₂).rnDeriv μ x = ν₁.rnDeriv μ x
state_after: no goals
tactic: simp [hx_add, hx_zero]
Theorem: add_sub_assoc
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivInvMonoid G
a✝ b✝ c✝ a b c : G
⊢ a * b / c = a * (b / c)
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_assoc _ _ _]
Theorem: Complex.sin_eq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y z : ℂ
⊢ sin z = sin ↑z.re * cosh ↑z.im + cos ↑z.re * sinh ↑z.im * I
state_after: case h.e'_2.h.e'_1
x y z : ℂ
⊢ z = ↑z.re + ↑z.im * I
tactic: convert sin_add_mul_I z.re z.im
state_before: case h.e'_2.h.e'_1
x y z : ℂ
⊢ z = ↑z.re + ↑z.im * I
state_after: no goals
tactic: exact (re_add_im z).symm
Theorem: Filter.frequently_true_iff_neBot
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
⊢ (∃ᶠ (x : α) in f, True) ↔ f.NeBot
state_after: no goals
tactic: simp [frequently_iff_neBot]
Theorem: uniqueDiffOn_Iic
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ (interior (Iic a)).Nonempty
state_after: no goals
tactic: simp only [interior_Iic, nonempty_Iio]