ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: geometric_hahn_banach_point_point
File: Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
s t : Set E
x y : E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
hxy : x ≠ y
⊢ ∃ f, f x < f y
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
hxy : x ≠ y
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ a ∈ {x}, f a < s
st : s < t
ht : ∀ b ∈ {y}, t < f b
⊢ ∃ f, f x < f y
tactic: obtain ⟨f, s, t, hs, st, ht⟩ :=
    geometric_hahn_banach_compact_closed (convex_singleton x) isCompact_singleton
      (convex_singleton y) isClosed_singleton (disjoint_singleton.2 hxy)
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
hxy : x ≠ y
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ a ∈ {x}, f a < s
st : s < t
ht : ∀ b ∈ {y}, t < f b
⊢ ∃ f, f x < f y
state_after: no goals
tactic: exact ⟨f, by linarith [hs x rfl, ht y rfl]⟩
Theorem: Matroid.eq_of_base_iff_base_forall
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
M₁ M₂ : Matroid α
hE : M₁.E = M₂.E
h : ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.Base B ↔ M₂.Base B)
⊢ M₁ = M₂
state_after: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
M₁ M₂ : Matroid α
hE : M₁.E = M₂.E
h : ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.Base B ↔ M₂.Base B)
h' : ∀ (B : Set α), M₁.Base B ↔ M₂.Base B
⊢ M₁ = M₂
tactic: have h' : ∀ B, M₁.Base B ↔ M₂.Base B :=
    fun B ↦ ⟨fun hB ↦ (h hB.subset_ground).1 hB,
      fun hB ↦ (h <| hB.subset_ground.trans_eq hE.symm).2 hB⟩
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
M₁ M₂ : Matroid α
hE : M₁.E = M₂.E
h : ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.Base B ↔ M₂.Base B)
h' : ∀ (B : Set α), M₁.Base B ↔ M₂.Base B
⊢ M₁ = M₂
state_after: no goals
tactic: ext <;> simp [hE, M₁.indep_iff', M₂.indep_iff', h']
Theorem: Complex.arg_conj_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ ↑((starRingEnd ℂ) x).arg = -↑x.arg
state_after: no goals
tactic: by_cases h : arg x = π <;> simp [arg_conj, h]
Theorem: LinearMap.compMultilinearMap_alternatization
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N'₂ : Type u_10
inst✝³ : AddCommGroup N'₂
inst✝² : Module R N'₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
g : N' →ₗ[R] N'₂
f : MultilinearMap R (fun x => M) N'
⊢ MultilinearMap.alternatization (g.compMultilinearMap f) = g.compAlternatingMap (MultilinearMap.alternatization f)
state_after: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N'₂ : Type u_10
inst✝³ : AddCommGroup N'₂
inst✝² : Module R N'₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
g : N' →ₗ[R] N'₂
f : MultilinearMap R (fun x => M) N'
x✝ : ι → M
⊢ (MultilinearMap.alternatization (g.compMultilinearMap f)) x✝ =
    (g.compAlternatingMap (MultilinearMap.alternatization f)) x✝
tactic: ext
state_before: case H
R : Type u_1
inst✝¹⁴ : Semiring R
M : Type u_2
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
N : Type u_3
inst✝¹¹ : AddCommMonoid N
inst✝¹⁰ : Module R N
P : Type u_4
inst✝⁹ : AddCommMonoid P
inst✝⁸ : Module R P
M' : Type u_5
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
N' : Type u_6
inst✝⁵ : AddCommGroup N'
inst✝⁴ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
N'₂ : Type u_10
inst✝³ : AddCommGroup N'₂
inst✝² : Module R N'₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
g : N' →ₗ[R] N'₂
f : MultilinearMap R (fun x => M) N'
x✝ : ι → M
⊢ (MultilinearMap.alternatization (g.compMultilinearMap f)) x✝ =
    (g.compAlternatingMap (MultilinearMap.alternatization f)) x✝
state_after: no goals
tactic: simp [MultilinearMap.alternatization_def]
Theorem: List.last_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
h : ofFn f ≠ []
hn : optParam (n - 1 < n) ⋯
⊢ (ofFn f).getLast h = f ⟨n - 1, hn⟩
state_after: no goals
tactic: simp [getLast_eq_get]
Theorem: NormedSpace.eq_zero_of_forall_dual_eq_zero
File: Mathlib/Analysis/Normed/Module/Dual.lean

Proof steps:
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
h : ∀ (f : Dual 𝕜 E), f x = 0
f : Dual 𝕜 E
⊢ ‖f x‖ ≤ 0 * ‖f‖
state_after: no goals
tactic: simp [h f]
Theorem: Nat.eleven_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n : ℕ
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ ofDigits (-1) (digits 10 n)
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
tactic: have t := dvd_iff_dvd_ofDigits 11 10 (-1 : ℤ) (by norm_num) n
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ ofDigits (-1) (digits 10 n)
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
tactic: rw [ofDigits_neg_one] at t
state_before: n : ℕ
t : 11 ∣ n ↔ ↑11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
⊢ 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (digits 10 n)).alternatingSum
state_after: no goals
tactic: exact t
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.fromSpec_toSpec
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x) = x
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ ∀ (i : ℕ),
    ∀ x_1 ∈ 𝒜 i, x_1 ∈ (↑(FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x))).asHomogeneousIdeal ↔ x_1 ∈ (↑x).asHomogeneousIdeal
tactic: refine Subtype.ext <| ProjectiveSpectrum.ext _ _ <| HomogeneousIdeal.ext' ?_
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ ∀ (i : ℕ),
    ∀ x_1 ∈ 𝒜 i, x_1 ∈ (↑(FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x))).asHomogeneousIdeal ↔ x_1 ∈ (↑x).asHomogeneousIdeal
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
i : ℕ
z : A
hzi : z ∈ 𝒜 i
⊢ z ∈ (↑(FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x))).asHomogeneousIdeal ↔ z ∈ (↑x).asHomogeneousIdeal
tactic: intros i z hzi
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
i : ℕ
z : A
hzi : z ∈ 𝒜 i
⊢ z ∈ (↑(FromSpec.toFun f_deg hm ((toSpec 𝒜 f) x))).asHomogeneousIdeal ↔ z ∈ (↑x).asHomogeneousIdeal
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
i : ℕ
z : A
hzi : z ∈ 𝒜 i
⊢ HomogeneousLocalization.mk { deg := m * i, num := ⟨z ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ } ∈
      ((toSpec 𝒜 f) x).asIdeal ↔
    z ∈ (↑x).asHomogeneousIdeal
tactic: refine (FromSpec.mem_carrier_iff_of_mem f_deg hm _ _ hzi).trans ?_
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
i : ℕ
z : A
hzi : z ∈ 𝒜 i
⊢ HomogeneousLocalization.mk { deg := m * i, num := ⟨z ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ } ∈
      ((toSpec 𝒜 f) x).asIdeal ↔
    z ∈ (↑x).asHomogeneousIdeal
state_after: no goals
tactic: exact (ToSpec.mk_mem_carrier _ _).trans (x.1.2.pow_mem_iff_mem m hm)
Theorem: CategoryTheory.Limits.Cotrident.ofCocone_ι
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
t : Cocone F
j : WalkingParallelFamily J
⊢ (parallelFamily fun j => F.map (line j)).obj j = F.obj j
state_after: no goals
tactic: cases j <;> aesop_cat
Theorem: MulChar.sum_one_eq_card_units
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommMonoid R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : DecidableEq R
⊢ ∑ a : R, 1 a = ↑(Fintype.card Rˣ)
state_after: case calc_1
R : Type u_1
inst✝³ : CommMonoid R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : DecidableEq R
a : R
x✝ : a ∈ Finset.univ
⊢ 1 a = if IsUnit a then 1 else 0

case calc_2
R : Type u_1
inst✝³ : CommMonoid R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : DecidableEq R
⊢ ↑(Finset.filter IsUnit Finset.univ).card = ↑(Finset.map { toFun := Units.val, inj' := ⋯ } Finset.univ).card
tactic: calc
    (∑ a, (1 : MulChar R R') a) = ∑ a : R, if IsUnit a then 1 else 0 :=
      Finset.sum_congr rfl fun a _ => ?_
    _ = ((Finset.univ : Finset R).filter IsUnit).card := Finset.sum_boole _ _
    _ = (Finset.univ.map ⟨((↑) : Rˣ → R), Units.ext⟩).card := ?_
    _ = Fintype.card Rˣ := congr_arg _ (Finset.card_map _)
Theorem: ENNReal.sInf_add
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
⊢ sInf s + a = ⨅ b ∈ s, b + a
state_after: no goals
tactic: simp [sInf_eq_iInf, iInf_add]
Theorem: SetTheory.PGame.zero_lf_le
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i
state_after: xl xr : Type u
x : PGame
⊢ ((∃ i, 0 ≤ x.moveLeft i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ x.moveLeft i
tactic: rw [lf_iff_exists_le]
state_before: xl xr : Type u
x : PGame
⊢ ((∃ i, 0 ≤ x.moveLeft i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ x.moveLeft i
state_after: no goals
tactic: simp
Theorem: UniqueMul.iff_card_le_one
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq G
ha0 : a0 ∈ A
hb0 : b0 ∈ B
⊢ UniqueMul A B a0 b0 ↔ (filter (fun p => p.1 * p.2 = a0 * b0) (A ×ˢ B)).card ≤ 1
state_after: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq G
ha0 : a0 ∈ A
hb0 : b0 ∈ B
⊢ UniqueMul A B a0 b0 ↔
    ∀ {a b : G × G}, (a.1 ∈ A ∧ a.2 ∈ B) ∧ a.1 * a.2 = a0 * b0 → (b.1 ∈ A ∧ b.2 ∈ B) ∧ b.1 * b.2 = a0 * b0 → a = b
tactic: simp_rw [card_le_one_iff, mem_filter, mem_product]
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq G
ha0 : a0 ∈ A
hb0 : b0 ∈ B
⊢ UniqueMul A B a0 b0 ↔
    ∀ {a b : G × G}, (a.1 ∈ A ∧ a.2 ∈ B) ∧ a.1 * a.2 = a0 * b0 → (b.1 ∈ A ∧ b.2 ∈ B) ∧ b.1 * b.2 = a0 * b0 → a = b
state_after: case refine_1
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq G
ha0 : a0 ∈ A
hb0 : b0 ∈ B
h : UniqueMul A B a0 b0
p1 p2 : G × G
x✝¹ : (p1.1 ∈ A ∧ p1.2 ∈ B) ∧ p1.1 * p1.2 = a0 * b0
x✝ : (p2.1 ∈ A ∧ p2.2 ∈ B) ∧ p2.1 * p2.2 = a0 * b0
ha1 : p1.1 ∈ A
hb1 : p1.2 ∈ B
he1 : p1.1 * p1.2 = a0 * b0
ha2 : p2.1 ∈ A
hb2 : p2.2 ∈ B
he2 : p2.1 * p2.2 = a0 * b0
⊢ p1 = p2

case refine_2
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq G
ha0 : a0 ∈ A
hb0 : b0 ∈ B
h : ∀ {a b : G × G}, (a.1 ∈ A ∧ a.2 ∈ B) ∧ a.1 * a.2 = a0 * b0 → (b.1 ∈ A ∧ b.2 ∈ B) ∧ b.1 * b.2 = a0 * b0 → a = b
a b : G
ha : a ∈ A
hb : b ∈ B
he : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
tactic: refine ⟨fun h p1 p2 ⟨⟨ha1, hb1⟩, he1⟩ ⟨⟨ha2, hb2⟩, he2⟩ ↦ ?_, fun h a b ha hb he ↦ ?_⟩
Theorem: IsAddCentral.right_comm
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
a✝ b✝ c : M
inst✝ : Mul M
h : IsMulCentral c
a b : M
⊢ a * b * c = a * c * b
state_after: no goals
tactic: simp only [h.right_assoc, h.mid_assoc, h.comm]
Theorem: Algebra.adjoin_adjoin_of_tower
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t s : Set A
⊢ adjoin S ↑(adjoin R s) = adjoin S s
state_after: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t s : Set A
⊢ adjoin S s ≤ adjoin S ↑(adjoin R s)

R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s✝ t s : Set A
⊢ ↑(adjoin R s) ⊆ ↑(adjoin S s)
tactic: apply le_antisymm (adjoin_le _)
Theorem: Sum.liftRel_inl_inl
File: .lake/packages/batteries/Batteries/Data/Sum/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
γ✝ : Type u_2
r : α✝ → γ✝ → Prop
β✝ : Type u_3
δ✝ : Type u_4
s : β✝ → δ✝ → Prop
a : α✝
c : γ✝
h : LiftRel r s (inl a) (inl c)
⊢ r a c
state_after: case inl
α✝ : Type u_1
γ✝ : Type u_2
r : α✝ → γ✝ → Prop
β✝ : Type u_3
δ✝ : Type u_4
s : β✝ → δ✝ → Prop
a : α✝
c : γ✝
a✝ : r a c
⊢ r a c
tactic: cases h
state_before: case inl
α✝ : Type u_1
γ✝ : Type u_2
r : α✝ → γ✝ → Prop
β✝ : Type u_3
δ✝ : Type u_4
s : β✝ → δ✝ → Prop
a : α✝
c : γ✝
a✝ : r a c
⊢ r a c
state_after: no goals
tactic: assumption
Theorem: SimpleGraph.card_incidenceSet_eq_degree
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝¹ : Fintype ↑(G.neighborSet v)
inst✝ : DecidableEq V
⊢ Fintype.card ↑(G.incidenceSet v) = G.degree v
state_after: V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝¹ : Fintype ↑(G.neighborSet v)
inst✝ : DecidableEq V
⊢ Fintype.card ↑(G.neighborSet v) = G.degree v
tactic: rw [Fintype.card_congr (G.incidenceSetEquivNeighborSet v)]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝¹ : Fintype ↑(G.neighborSet v)
inst✝ : DecidableEq V
⊢ Fintype.card ↑(G.neighborSet v) = G.degree v
state_after: no goals
tactic: simp
Theorem: continuousAt_clog
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: α : Type u_1
x : ℂ
h : x ∈ slitPlane
⊢ ContinuousAt log x
state_after: case refine_1
α : Type u_1
x : ℂ
h : x ∈ slitPlane
⊢ ContinuousAt (fun x => ↑(Real.log (Complex.abs x))) x

case refine_2
α : Type u_1
x : ℂ
h : x ∈ slitPlane
⊢ ContinuousAt (fun x => ↑x.arg * I) x
tactic: refine ContinuousAt.add ?_ ?_
Theorem: selfAdjointPart_comp_subtype_skewAdjoint
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x✝ : ↥(skewAdjoint.submodule R A)
x : A
hx : star x = -x
⊢ ↑((selfAdjointPart R ∘ₗ (skewAdjoint.submodule R A).subtype) ⟨x, hx⟩) = ↑(0 ⟨x, hx⟩)
state_after: no goals
tactic: simp [hx]
Theorem: WeakFEPair.symm_Λ₀_eq
File: Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
s : ℂ
⊢ P.symm.Λ₀ s = P.symm.Λ s + (1 / s) • P.g₀ + (P.ε⁻¹ / (↑P.k - s)) • P.f₀
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
s : ℂ
⊢ P.symm.Λ s + (1 / s) • P.symm.f₀ + (P.symm.ε / (↑P.symm.k - s)) • P.symm.g₀ =
    P.symm.Λ s + (1 / s) • P.g₀ + (P.ε⁻¹ / (↑P.k - s)) • P.f₀
tactic: rw [P.symm.Λ₀_eq]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
s : ℂ
⊢ P.symm.Λ s + (1 / s) • P.symm.f₀ + (P.symm.ε / (↑P.symm.k - s)) • P.symm.g₀ =
    P.symm.Λ s + (1 / s) • P.g₀ + (P.ε⁻¹ / (↑P.k - s)) • P.f₀
state_after: no goals
tactic: rfl
Theorem: vadd_eq_vadd_iff_sub_eq_vsub
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
v₁ v₂ : G
p₁ p₂ : P
⊢ v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂
state_after: no goals
tactic: rw [vadd_eq_vadd_iff_neg_add_eq_vsub, neg_add_eq_sub]
Theorem: IsOfFinOrder.prod_mk
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✝¹ : Monoid α
inst✝ : Monoid β
x : α × β
a : α
b : β
⊢ IsOfFinOrder a → IsOfFinOrder b → IsOfFinOrder (a, b)
state_after: no goals
tactic: simpa only [← orderOf_pos_iff, Prod.orderOf] using Nat.lcm_pos
Theorem: Set.infsep_pos_iff_nontrivial_of_finite
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MetricSpace α
s : Set α
inst✝ : Finite ↑s
⊢ 0 < s.infsep ↔ s.Nontrivial
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MetricSpace α
s : Set α
inst✝ : Finite ↑s
⊢ s.Nontrivial → 0 < s.einfsep
tactic: rw [infsep_pos, einfsep_lt_top_iff, and_iff_right_iff_imp]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MetricSpace α
s : Set α
inst✝ : Finite ↑s
⊢ s.Nontrivial → 0 < s.einfsep
state_after: no goals
tactic: exact fun _ => einfsep_pos_of_finite
Theorem: LieHom.mk_coe
File: Mathlib/Algebra/Lie/Basic.lean

Proof steps:
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), f (x + y) = f x + f y
h₂ :
  ∀ (m : R) (x : L₁),
    { toFun := ⇑f, map_add' := h₁ }.toFun (m • x) = (RingHom.id R) m • { toFun := ⇑f, map_add' := h₁ }.toFun x
h₃ :
  ∀ {x y : L₁},
    { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun ⁅x, y⁆ =
      ⁅{ toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun x,
        { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun y⁆
⊢ { toFun := ⇑f, map_add' := h₁, map_smul' := h₂, map_lie' := h₃ } = f
state_after: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), f (x + y) = f x + f y
h₂ :
  ∀ (m : R) (x : L₁),
    { toFun := ⇑f, map_add' := h₁ }.toFun (m • x) = (RingHom.id R) m • { toFun := ⇑f, map_add' := h₁ }.toFun x
h₃ :
  ∀ {x y : L₁},
    { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun ⁅x, y⁆ =
      ⁅{ toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun x,
        { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun y⁆
x✝ : L₁
⊢ { toFun := ⇑f, map_add' := h₁, map_smul' := h₂, map_lie' := h₃ } x✝ = f x✝
tactic: ext
state_before: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), f (x + y) = f x + f y
h₂ :
  ∀ (m : R) (x : L₁),
    { toFun := ⇑f, map_add' := h₁ }.toFun (m • x) = (RingHom.id R) m • { toFun := ⇑f, map_add' := h₁ }.toFun x
h₃ :
  ∀ {x y : L₁},
    { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun ⁅x, y⁆ =
      ⁅{ toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun x,
        { toFun := ⇑f, map_add' := h₁, map_smul' := h₂ }.toFun y⁆
x✝ : L₁
⊢ { toFun := ⇑f, map_add' := h₁, map_smul' := h₂, map_lie' := h₃ } x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.PreGaloisCategory.autMulEquivAutGalois_π
File: Mathlib/CategoryTheory/Galois/Prorepresentability.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ }) (MulOpposite.unop ((autMulEquivAutGalois F) f))).hom a =
    f.hom.app A a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map
      ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ })
          ((endEquivAutGalois F) ↑((Aut.unitsEndEquivAut F).symm f))).hom
      a =
    f.hom.app A a
tactic: dsimp [autMulEquivAutGalois, endMulEquivAutGalois]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ F.map
      ((AutGalois.π F { obj := A, pt := a, isGalois := ⋯ })
          ((endEquivAutGalois F) ↑((Aut.unitsEndEquivAut F).symm f))).hom
      a =
    f.hom.app A a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ (↑((Aut.unitsEndEquivAut F).symm f)).app { obj := A, pt := a, isGalois := ⋯ }.obj
      { obj := A, pt := a, isGalois := ⋯ }.pt =
    f.hom.app A a
tactic: rw [endEquivAutGalois_π]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
f : Aut F
A : C
inst✝ : IsGalois A
a : ↑(F.obj A)
⊢ (↑((Aut.unitsEndEquivAut F).symm f)).app { obj := A, pt := a, isGalois := ⋯ }.obj
      { obj := A, pt := a, isGalois := ⋯ }.pt =
    f.hom.app A a
state_after: no goals
tactic: rfl
Theorem: Complex.Gammaℂ_add_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

Proof steps:
state_before: s : ℂ
hs : s ≠ 0
⊢ (s + 1).Gammaℂ = s.Gammaℂ * s / 2 / ↑π
state_after: s : ℂ
hs : s ≠ 0
⊢ 2 * ((2 * ↑π) ^ (-s) * (2 * ↑π)⁻¹) * (s * Gamma s) = 2 * (2 * ↑π) ^ (-s) * Gamma s * s / 2 / ↑π
tactic: rw [Gammaℂ_def, Gammaℂ_def, Gamma_add_one _ hs, neg_add,
    cpow_add _ _ (mul_ne_zero two_ne_zero (ofReal_ne_zero.mpr pi_ne_zero)), cpow_neg_one]
state_before: s : ℂ
hs : s ≠ 0
⊢ 2 * ((2 * ↑π) ^ (-s) * (2 * ↑π)⁻¹) * (s * Gamma s) = 2 * (2 * ↑π) ^ (-s) * Gamma s * s / 2 / ↑π
state_after: s : ℂ
hs : s ≠ 0
⊢ 2 * (2 * ↑π) ^ (-s) * (s * Gamma s) = 2 * (2 * ↑π) ^ (-s) * Gamma s * s
tactic: field_simp [pi_ne_zero]
state_before: s : ℂ
hs : s ≠ 0
⊢ 2 * (2 * ↑π) ^ (-s) * (s * Gamma s) = 2 * (2 * ↑π) ^ (-s) * Gamma s * s
state_after: no goals
tactic: ring