ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.ofReal_cos_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (cos ↑x) = cos ↑x
state_after: no goals
tactic: rw [← cos_conj, conj_ofReal]
Theorem: FirstOrder.Language.BoundedFormula.realize_iSup
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
s : Finset β
f : β → L.BoundedFormula α n
v : α → M
v' : Fin n → M
⊢ (iSup s f).Realize v v' ↔ ∃ b ∈ s, (f b).Realize v v'
state_after: no goals
tactic: simp only [iSup, realize_foldr_sup, List.mem_map, Finset.mem_toList,
    exists_exists_and_eq_and]
Theorem: _private.Mathlib.Algebra.Order.UpperLower.0.UpperSet.one_mul
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : UpperSet α
⊢ Set.Ici 1 * ↑s ⊆ ↑s
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : UpperSet α
⊢ ⋃ a ∈ Set.Ici 1, a • ↑s ⊆ ↑s
tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : UpperSet α
⊢ ⋃ a ∈ Set.Ici 1, a • ↑s ⊆ ↑s
state_after: no goals
tactic: exact Set.iUnion₂_subset fun _ ↦ s.upper.smul_subset
Theorem: CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ (colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom) ≫ (colimitIsoColimitCurryCompColim G).inv =
    (colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j) ≫ (colimitIsoColimitCurryCompColim G).inv
tactic: rw [← cancel_mono (colimitIsoColimitCurryCompColim G).inv]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ (colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom) ≫ (colimitIsoColimitCurryCompColim G).inv =
    (colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j) ≫ (colimitIsoColimitCurryCompColim G).inv
state_after: no goals
tactic: simp
Theorem: inner_eq_norm_mul_iff_div
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ : x ≠ 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ h₀' : x ≠ 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y
tactic: have h₀' := h₀
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ h₀' : x ≠ 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ : x ≠ 0
h₀' : ¬↑‖x‖ = 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y
tactic: rw [← norm_ne_zero_iff, Ne, ← @ofReal_eq_zero 𝕜] at h₀'
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ : x ≠ 0
h₀' : ¬↑‖x‖ = 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y
state_after: case mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ : x ≠ 0
h₀' : ¬↑‖x‖ = 0
h : ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖
⊢ (↑‖y‖ / ↑‖x‖) • x = y

case mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
h₀ : x ≠ 0
h₀' : ¬↑‖x‖ = 0
h : (↑‖y‖ / ↑‖x‖) • x = y
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖
tactic: constructor <;> intro h
Theorem: Nat.multinomial_empty
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
⊢ multinomial ∅ f = 1
state_after: no goals
tactic: simp [multinomial]
Theorem: HurwitzZeta.differentiableAt_one_completedHurwitzZetaEven_sub_completedHurwitzZetaEven
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a b : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s - completedHurwitzZetaEven b s) 1
state_after: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s - completedHurwitzZetaEven b s) 1
tactic: have (s) : completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
      ((if a = 0 then 1 else 0) - (if b = 0 then 1 else 0)) / s := by
    simp_rw [completedHurwitzZetaEven_eq, sub_div]
    abel
state_before: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ (fun s => completedHurwitzZetaEven a s - completedHurwitzZetaEven b s) 1
state_after: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ
    (fun x =>
      completedHurwitzZetaEven₀ a x - completedHurwitzZetaEven₀ b x -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / x)
    1
tactic: rw [funext this]
state_before: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ
    (fun x =>
      completedHurwitzZetaEven₀ a x - completedHurwitzZetaEven₀ b x -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / x)
    1
state_after: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ (fun x => completedHurwitzZetaEven₀ a x - completedHurwitzZetaEven₀ b x) 1
tactic: refine .sub ?_ <| (differentiable_const _ _).div (differentiable_id _) one_ne_zero
state_before: a b : UnitAddCircle
this :
  ∀ (s : ℂ),
    completedHurwitzZetaEven a s - completedHurwitzZetaEven b s =
      completedHurwitzZetaEven₀ a s - completedHurwitzZetaEven₀ b s -
        ((if a = 0 then 1 else 0) - if b = 0 then 1 else 0) / s
⊢ DifferentiableAt ℂ (fun x => completedHurwitzZetaEven₀ a x - completedHurwitzZetaEven₀ b x) 1
state_after: no goals
tactic: apply DifferentiableAt.sub <;> apply differentiable_completedHurwitzZetaEven₀
Theorem: PNat.XgcdType.finish_isReduced
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u : XgcdType
⊢ u.finish.IsReduced
state_after: u : XgcdType
⊢ u.finish.ap = u.finish.bp
tactic: dsimp [IsReduced]
state_before: u : XgcdType
⊢ u.finish.ap = u.finish.bp
state_after: no goals
tactic: rfl
Theorem: infinite_prod
File: Mathlib/Data/Fintype/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
⊢ Infinite (α × β) ↔ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β
tactic: refine
    ⟨fun H => ?_, fun H =>
      H.elim (and_imp.2 <| @Prod.infinite_of_left α β) (and_imp.2 <| @Prod.infinite_of_right α β)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Nonempty β ∧ Infinite α ∨ Nonempty α ∧ Infinite β
tactic: rw [and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Nonempty β ∧ Infinite α ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
⊢ ¬Infinite (α × β)
tactic: contrapose! H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
⊢ ¬Infinite (α × β)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
⊢ False
tactic: intro H'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
⊢ False
tactic: rcases Infinite.nonempty (α × β) with ⟨a, b⟩
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this : Fintype α
⊢ False
tactic: haveI := fintypeOfNotInfinite (H.1 ⟨b⟩)
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this : Fintype α
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this✝ : Fintype α
this : Fintype β
⊢ False
tactic: haveI := fintypeOfNotInfinite (H.2 ⟨a⟩)
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this✝ : Fintype α
this : Fintype β
⊢ False
state_after: no goals
tactic: exact H'.false
Theorem: LinearMap.graph_eq_range_prod
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✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ f.graph = range (id.prod f)
state_after: case h
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✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M × M₂
⊢ x ∈ f.graph ↔ x ∈ range (id.prod f)
tactic: ext x
state_before: case h
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✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M × M₂
⊢ x ∈ f.graph ↔ x ∈ range (id.prod f)
state_after: no goals
tactic: exact ⟨fun hx => ⟨x.1, Prod.ext rfl hx.symm⟩, fun ⟨u, hu⟩ => hu ▸ rfl⟩
Theorem: WittVector.frobeniusPoly_zmod
File: Mathlib/RingTheory/WittVector/Frobenius.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPoly p n) = X n ^ p
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X n ^ p + C ((Int.castRingHom (ZMod p)) ↑p) * (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPolyAux p n) =
    X n ^ p
tactic: rw [frobeniusPoly, RingHom.map_add, RingHom.map_pow, RingHom.map_mul, map_X, map_C]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X n ^ p + C ((Int.castRingHom (ZMod p)) ↑p) * (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPolyAux p n) =
    X n ^ p
state_after: no goals
tactic: simp only [Int.cast_natCast, add_zero, eq_intCast, ZMod.natCast_self, zero_mul, C_0]
Theorem: List.Perm.rec_heq
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : List α → Sort u_2
f : (a : α) → (l : List α) → β l → β (a :: l)
b : β []
l l' : List α
hl : l ~ l'
f_congr : ∀ {a : α} {l l' : List α} {b : β l} {b' : β l'}, l ~ l' → HEq b b' → HEq (f a l b) (f a l' b')
f_swap : ∀ {a a' : α} {l : List α} {b : β l}, HEq (f a (a' :: l) (f a' l b)) (f a' (a :: l) (f a l b))
⊢ HEq (List.rec b f l) (List.rec b f l')
state_after: no goals
tactic: induction hl with
  | nil => rfl
  | cons a h ih => exact f_congr h ih
  | swap a a' l => exact f_swap
  | trans _h₁ _h₂ ih₁ ih₂ => exact ih₁.trans ih₂
Theorem: Basis.toDual_injective
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.repr x) i = (b.repr y) i
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.toDual x) (b i) = (b.toDual y) (b i)
tactic: simp_rw [← toDual_eq_repr]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
x y : M
h : b.toDual x = b.toDual y
i : ι
⊢ (b.toDual x) (b i) = (b.toDual y) (b i)
state_after: no goals
tactic: exact DFunLike.congr_fun h _
Theorem: HomologicalComplex.comp_liftCycles
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.27008, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j✝ k✝ : ι
inst✝ : K.HasHomology i
A' A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
hk : k ≫ K.d i j = 0
α : A' ⟶ A
⊢ (α ≫ k) ≫ K.d i j = 0
state_after: no goals
tactic: rw [assoc, hk, comp_zero]
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j✝ k✝ : ι
inst✝ : K.HasHomology i
A' A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
hk : k ≫ K.d i j = 0
α : A' ⟶ A
⊢ α ≫ K.liftCycles k j hj hk = K.liftCycles (α ≫ k) j hj ⋯
state_after: no goals
tactic: simp only [← cancel_mono (K.iCycles i), assoc, liftCycles_i]
Theorem: irreducibleComponents_eq_maximals_closed
File: Mathlib/Topology/Irreducible.lean

Proof steps:
state_before: X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s t : Set X✝
X : Type u_3
inst✝ : TopologicalSpace X
⊢ irreducibleComponents X = maximals (fun x x_1 => x ≤ x_1) {s | IsClosed s ∧ IsIrreducible s}
state_after: case h
X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : Type u_3
inst✝ : TopologicalSpace X
s : Set X
⊢ s ∈ irreducibleComponents X ↔ s ∈ maximals (fun x x_1 => x ≤ x_1) {s | IsClosed s ∧ IsIrreducible s}
tactic: ext s
state_before: case h
X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : Type u_3
inst✝ : TopologicalSpace X
s : Set X
⊢ s ∈ irreducibleComponents X ↔ s ∈ maximals (fun x x_1 => x ≤ x_1) {s | IsClosed s ∧ IsIrreducible s}
state_after: case h.mp
X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : Type u_3
inst✝ : TopologicalSpace X
s : Set X
⊢ s ∈ irreducibleComponents X → s ∈ maximals (fun x x_1 => x ≤ x_1) {s | IsClosed s ∧ IsIrreducible s}

case h.mpr
X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : Type u_3
inst✝ : TopologicalSpace X
s : Set X
⊢ s ∈ maximals (fun x x_1 => x ≤ x_1) {s | IsClosed s ∧ IsIrreducible s} → s ∈ irreducibleComponents X
tactic: constructor
Theorem: Mathlib.Tactic.Monoidal.eval_whiskerRight
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
f f' g g' h i j : C
η η' : f ⟶ g
θ : f ⊗ h ⟶ g ⊗ h
pf_η : η = η'
pf_θ : η' ▷ h = θ
⊢ η ▷ h = θ
state_after: no goals
tactic: simp [pf_η, pf_θ]
Theorem: CharacterModule.eq_zero_of_character_apply
File: Mathlib/Algebra/Module/CharacterModule.lean

Proof steps:
state_before: R : Type uR
inst✝³ : CommRing R
A : Type uA
inst✝² : AddCommGroup A
A' : Type u_1
inst✝¹ : AddCommGroup A'
B : Type uB
inst✝ : AddCommGroup B
a : A
h : ∀ (c : CharacterModule A), c a = 0
⊢ a = 0
state_after: R : Type uR
inst✝³ : CommRing R
A : Type uA
inst✝² : AddCommGroup A
A' : Type u_1
inst✝¹ : AddCommGroup A'
B : Type uB
inst✝ : AddCommGroup B
a : A
h : a ≠ 0
⊢ ∃ c, c a ≠ 0
tactic: contrapose! h
state_before: R : Type uR
inst✝³ : CommRing R
A : Type uA
inst✝² : AddCommGroup A
A' : Type u_1
inst✝¹ : AddCommGroup A'
B : Type uB
inst✝ : AddCommGroup B
a : A
h : a ≠ 0
⊢ ∃ c, c a ≠ 0
state_after: no goals
tactic: exact exists_character_apply_ne_zero_of_ne_zero h
Theorem: padicNormE.add_eq_max_of_ne
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
h : ‖q‖ ≠ ‖r‖
⊢ ‖q + r‖ = max ‖q‖ ‖r‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
h : ¬↑(padicNormE q) = ↑(padicNormE r)
⊢ ↑(padicNormE (q + r)) = max ↑(padicNormE q) ↑(padicNormE r)
tactic: dsimp [norm] at h ⊢
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
h : ¬↑(padicNormE q) = ↑(padicNormE r)
⊢ ↑(padicNormE (q + r)) = max ↑(padicNormE q) ↑(padicNormE r)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
h : ¬↑(padicNormE q) = ↑(padicNormE r)
this : padicNormE q ≠ padicNormE r
⊢ ↑(padicNormE (q + r)) = max ↑(padicNormE q) ↑(padicNormE r)
tactic: have : padicNormE q ≠ padicNormE r := mod_cast h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
h : ¬↑(padicNormE q) = ↑(padicNormE r)
this : padicNormE q ≠ padicNormE r
⊢ ↑(padicNormE (q + r)) = max ↑(padicNormE q) ↑(padicNormE r)
state_after: no goals
tactic: exact mod_cast add_eq_max_of_ne' this
Theorem: List.Chain'.two_mul_count_bool_le_length_add_one
File: Mathlib/Data/Bool/Count.lean

Proof steps:
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ 2 * count b l ≤ l.length + 1
state_after: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ (if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1) ≤ l.length + 1
tactic: rw [hl.two_mul_count_bool_eq_ite]
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ (if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1) ≤ l.length + 1
state_after: no goals
tactic: split_ifs <;> simp [Nat.le_succ_of_le]
Theorem: Sym2.congr_right
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ s(a, b) = s(a, c) ↔ b = c
state_after: no goals
tactic: simp (config := {contextual := true})
Theorem: Complex.cosh_add
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh (x + y) = cosh x * cosh y + sinh x * sinh y
state_after: x y : ℂ
⊢ (cexp x + cexp (-x)) * (cexp y + cexp (-y)) + (cexp x - cexp (-x)) * (cexp y - cexp (-y)) =
    2 * (cexp x * cexp y + cexp (-x) * cexp (-y))
tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), two_cosh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
    mul_assoc, two_cosh, ← mul_assoc, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
    mul_left_comm, two_cosh, mul_left_comm, two_sinh]
state_before: x y : ℂ
⊢ (cexp x + cexp (-x)) * (cexp y + cexp (-y)) + (cexp x - cexp (-x)) * (cexp y - cexp (-y)) =
    2 * (cexp x * cexp y + cexp (-x) * cexp (-y))
state_after: no goals
tactic: exact cosh_add_aux