ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.biprod.map_eq_map'
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ map f g = map' f g
state_after: case h₀.h₀
J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inl ≫ map f g) ≫ fst = (inl ≫ map' f g) ≫ fst

case h₀.h₁
J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inl ≫ map f g) ≫ snd = (inl ≫ map' f g) ≫ snd

case h₁.h₀
J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inr ≫ map f g) ≫ fst = (inr ≫ map' f g) ≫ fst

case h₁.h₁
J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ (inr ≫ map f g) ≫ snd = (inr ≫ map' f g) ≫ snd
tactic: ext
Theorem: div_mul_cancel
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✝ : Group G
a✝ b✝ c d : G
n : ℤ
a b : G
⊢ a / b * b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, inv_mul_cancel_right a b]
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_of_adj
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

Proof steps:
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - ℓ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
tactic: rw [← h.of_adj v w ha]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
ha : G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: no goals
tactic: apply h.card_neighborFinset_union_eq
Theorem: Profinite.NobelingProof.isClosed_C1
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed (C1 C ho)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = true}
tactic: refine hC.inter ?_
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ IsClosed {f | f (term I ho) = true}
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = true}
tactic: have h : Continuous (fun (f : I → Bool) ↦ f (term I ho)) := continuous_apply (term I ho)
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
h : Continuous fun f => f (term I ho)
⊢ IsClosed {f | f (term I ho) = true}
state_after: no goals
tactic: exact IsClosed.preimage h (t := {true}) (isClosed_discrete _)
Theorem: ENNReal.inv_mul_ne_top
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a⁻¹ * a ≠ ⊤
state_after: no goals
tactic: simp [mul_comm]
Theorem: CategoryTheory.ConcreteCategory.injective_eq_monomorphisms
File: Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesMonomorphisms
⊢ MorphismProperty.injective C = monomorphisms C
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesMonomorphisms
⊢ (forget C).PreservesMonomorphisms
tactic: rw [injective_eq_monomorphisms_iff]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : ConcreteCategory C
inst✝ : (forget C).PreservesMonomorphisms
⊢ (forget C).PreservesMonomorphisms
state_after: no goals
tactic: infer_instance
Theorem: Surreal.Multiplication.ih4_neg
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ IH4 x₁ x₂ y → IH4 (-x₂) (-x₁) y ∧ IH4 x₁ x₂ (-y)
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ (∀ ⦃z w : PGame⦄, w.IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)) →
    (∀ ⦃z w : PGame⦄, w.IsOption y → ((-z).IsOption x₂ → P2 z (-x₁) w) ∧ ((-z).IsOption x₁ → P2 (-x₂) z w)) ∧
      ∀ ⦃z w : PGame⦄, (-w).IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)
tactic: simp_rw [IH4, isOption_neg]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ (∀ ⦃z w : PGame⦄, w.IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)) →
    (∀ ⦃z w : PGame⦄, w.IsOption y → ((-z).IsOption x₂ → P2 z (-x₁) w) ∧ ((-z).IsOption x₁ → P2 (-x₂) z w)) ∧
      ∀ ⦃z w : PGame⦄, (-w).IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)
state_after: case refine_1
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z w : PGame⦄, w.IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)
z w : PGame
h' : w.IsOption y
⊢ ((-z).IsOption x₂ → P2 z (-x₁) w) ∧ ((-z).IsOption x₁ → P2 (-x₂) z w)

case refine_2
x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h : ∀ ⦃z w : PGame⦄, w.IsOption y → (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)
z w : PGame
h' : (-w).IsOption y
⊢ (z.IsOption x₁ → P2 z x₂ w) ∧ (z.IsOption x₂ → P2 x₁ z w)
tactic: refine fun h ↦ ⟨fun z w h' ↦ ?_, fun z w h' ↦ ?_⟩
Theorem: IsPerfectClosure.equiv_comp_equiv_apply_eq_self
File: Mathlib/FieldTheory/IsPerfectClosure.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝¹³ : CommRing K
inst✝¹² : CommRing L
inst✝¹¹ : CommRing M
inst✝¹⁰ : CommRing N
i : K →+* L
j : K →+* M
k : K →+* N
f : L →+* M
g : L →+* N
p : ℕ
inst✝⁹ : ExpChar K p
inst✝⁸ : ExpChar L p
inst✝⁷ : ExpChar M p
inst✝⁶ : ExpChar N p
inst✝⁵ : PerfectRing L p
inst✝⁴ : IsPerfectClosure i p
inst✝³ : PerfectRing M p
inst✝² : IsPerfectClosure j p
inst✝¹ : PerfectRing N p
inst✝ : IsPerfectClosure k p
x : L
⊢ (equiv j i p) ((equiv i j p) x) = x
state_after: no goals
tactic: rw [equiv_comp_equiv_apply, equiv_self_apply]
Theorem: Int.cast_commute
File: Mathlib/Data/Int/Cast/Lemmas.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : NonAssocRing α
a b : α
n✝ : ℤ
n : ℕ
x : α
⊢ Commute (↑↑n) x
state_after: no goals
tactic: simpa using n.cast_commute x
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : NonAssocRing α
a b : α
n✝ : ℤ
n : ℕ
x : α
⊢ Commute (↑-[n+1]) x
state_after: no goals
tactic: simpa only [cast_negSucc, Commute.neg_left_iff, Commute.neg_right_iff] using
      (n + 1).cast_commute (-x)
Theorem: GroupSeminorm.mul_bddBelow_range_add
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝² : FunLike F E ℝ
inst✝¹ : CommGroup E
inst✝ : CommGroup F
p✝ q✝ : GroupSeminorm E
x✝ y : E
p q : GroupSeminorm E
x : E
⊢ 0 ∈ lowerBounds (range fun y => p y + q (x / y))
state_after: case intro
ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝² : FunLike F E ℝ
inst✝¹ : CommGroup E
inst✝ : CommGroup F
p✝ q✝ : GroupSeminorm E
x✝¹ y : E
p q : GroupSeminorm E
x✝ x : E
⊢ 0 ≤ (fun y => p y + q (x✝ / y)) x
tactic: rintro _ ⟨x, rfl⟩
state_before: case intro
ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝² : FunLike F E ℝ
inst✝¹ : CommGroup E
inst✝ : CommGroup F
p✝ q✝ : GroupSeminorm E
x✝¹ y : E
p q : GroupSeminorm E
x✝ x : E
⊢ 0 ≤ (fun y => p y + q (x✝ / y)) x
state_after: case intro
ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝² : FunLike F E ℝ
inst✝¹ : CommGroup E
inst✝ : CommGroup F
p✝ q✝ : GroupSeminorm E
x✝¹ y : E
p q : GroupSeminorm E
x✝ x : E
⊢ 0 ≤ p x + q (x✝ / x)
tactic: dsimp
state_before: case intro
ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝² : FunLike F E ℝ
inst✝¹ : CommGroup E
inst✝ : CommGroup F
p✝ q✝ : GroupSeminorm E
x✝¹ y : E
p q : GroupSeminorm E
x✝ x : E
⊢ 0 ≤ p x + q (x✝ / x)
state_after: no goals
tactic: positivity
Theorem: MeasureTheory.hasFiniteIntegral_restrict_of_bounded
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f : α → E
s : Set α
μ : Measure α
C : ℝ
hs : μ s < ⊤
hf : ∀ᵐ (x : α) ∂μ.restrict s, ‖f x‖ ≤ C
⊢ (μ.restrict s) univ < ⊤
state_after: no goals
tactic: rwa [Measure.restrict_apply_univ]
Theorem: HurwitzZeta.completedCosZeta_residue_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => s * completedCosZeta a s) (𝓝[≠] 0) (𝓝 (-1))
state_after: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).symm.Λ s) (𝓝[≠] 0) (𝓝 (-1))
⊢ Tendsto (fun s => s * completedCosZeta a s) (𝓝[≠] 0) (𝓝 (-1))
tactic: have h1 : Tendsto (fun s : ℂ ↦ s * _) (𝓝[≠] 0)
    (𝓝 (-1)) := (hurwitzEvenFEPair a).symm.Λ_residue_zero
state_before: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).symm.Λ s) (𝓝[≠] 0) (𝓝 (-1))
⊢ Tendsto (fun s => s * completedCosZeta a s) (𝓝[≠] 0) (𝓝 (-1))
state_after: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).symm.Λ s) (𝓝[≠] 0) (𝓝 (-1))
s : ℂ
⊢ ((fun s => s * (hurwitzEvenFEPair a).symm.Λ s) ∘ fun s => s / 2) s = s * completedCosZeta a s
tactic: refine (h1.comp <| zero_div (2 : ℂ) ▸ (tendsto_div_two_punctured_nhds 0)).congr (fun s ↦ ?_)
state_before: a : UnitAddCircle
h1 : Tendsto (fun s => s * (hurwitzEvenFEPair a).symm.Λ s) (𝓝[≠] 0) (𝓝 (-1))
s : ℂ
⊢ ((fun s => s * (hurwitzEvenFEPair a).symm.Λ s) ∘ fun s => s / 2) s = s * completedCosZeta a s
state_after: no goals
tactic: rw [completedCosZeta, Function.comp_apply, div_mul_eq_mul_div, mul_div_assoc]
Theorem: Fin.succAbove_pos
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
inst✝ : NeZero n
p : Fin (n + 1)
i : Fin n
h : 0 < i
⊢ 0 < p.succAbove i
state_after: case pos
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
inst✝ : NeZero n
p : Fin (n + 1)
i : Fin n
h : 0 < i
H : i.castSucc < p
⊢ 0 < p.succAbove i

case neg
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
inst✝ : NeZero n
p : Fin (n + 1)
i : Fin n
h : 0 < i
H : ¬i.castSucc < p
⊢ 0 < p.succAbove i
tactic: by_cases H : castSucc i < p
Theorem: Zsqrtd.smuld_val
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d n x y : ℤ
⊢ sqrtd * ↑n * { re := x, im := y } = { re := d * n * y, im := n * x }
state_after: no goals
tactic: ext <;> simp
Theorem: MeasureTheory.HasFiniteIntegral.norm
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f μ
⊢ HasFiniteIntegral (fun a => ‖f a‖) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f μ
eq : (fun a => ↑‖‖f a‖‖₊) = fun a => ↑‖f a‖₊
⊢ HasFiniteIntegral (fun a => ‖f a‖) μ
tactic: have eq : (fun a => (nnnorm ‖f a‖ : ℝ≥0∞)) = fun a => (‖f a‖₊ : ℝ≥0∞) := by
    funext
    rw [nnnorm_norm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f μ
eq : (fun a => ↑‖‖f a‖‖₊) = fun a => ↑‖f a‖₊
⊢ HasFiniteIntegral (fun a => ‖f a‖) μ
state_after: no goals
tactic: rwa [HasFiniteIntegral, eq]
Theorem: Set.toFinset_Ici
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ici a)
⊢ (Ici a).toFinset = Finset.Ici a
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ici a)
a✝ : α
⊢ a✝ ∈ (Ici a).toFinset ↔ a✝ ∈ Finset.Ici a
tactic: ext
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderTop α
a : α
inst✝ : Fintype ↑(Ici a)
a✝ : α
⊢ a✝ ∈ (Ici a).toFinset ↔ a✝ ∈ Finset.Ici a
state_after: no goals
tactic: simp
Theorem: SimpleGraph.Walk.chain_dartAdj_darts
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
d : G.Dart
v w : V
h : d.toProd.2 = v
p : G.Walk v w
⊢ List.Chain G.DartAdj d p.darts
state_after: no goals
tactic: induction p generalizing d with
  | nil => exact List.Chain.nil
  -- Porting note: needed to defer `h` and `rfl` to help elaboration
  | cons h' p ih => exact List.Chain.cons (by exact h) (ih (by rfl))
Theorem: NonUnitalSubalgebra.toNonUnitalSubsemiring_injective
File: Mathlib/Algebra/Algebra/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✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : NonUnitalNonAssocSemiring B
inst✝³ : NonUnitalNonAssocSemiring C
inst✝² : Module R A
inst✝¹ : Module R B
inst✝ : Module R C
S T : NonUnitalSubalgebra R A
h : S.toNonUnitalSubsemiring = T.toNonUnitalSubsemiring
x : A
⊢ x ∈ S ↔ x ∈ T
state_after: no goals
tactic: rw [← mem_toNonUnitalSubsemiring, ← mem_toNonUnitalSubsemiring, h]
Theorem: DoubleCentralizer.norm_snd
File: Mathlib/Analysis/CstarAlgebra/Multiplier.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing A
inst✝⁴ : NormedSpace 𝕜 A
inst✝³ : SMulCommClass 𝕜 A A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : StarRing A
inst✝ : CstarRing A
a : 𝓜(𝕜, A)
⊢ ‖a.toProd.2‖ = ‖a‖
state_after: no goals
tactic: rw [← norm_fst, norm_fst_eq_snd]
Theorem: TopologicalSpace.Opens.isBasis_iff_cover
File: Mathlib/Topology/Sets/Opens.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
B : Set (Opens α)
⊢ IsBasis B ↔ ∀ (U : Opens α), ∃ Us ⊆ B, U = sSup Us
state_after: case mp
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
B : Set (Opens α)
⊢ IsBasis B → ∀ (U : Opens α), ∃ Us ⊆ B, U = sSup Us

case mpr
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
B : Set (Opens α)
⊢ (∀ (U : Opens α), ∃ Us ⊆ B, U = sSup Us) → IsBasis B
tactic: constructor
Theorem: Matroid.Base.mapEmbedding
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α ↪ β
⊢ (M.mapEmbedding f).Base (⇑f '' B)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α ↪ β
⊢ ∃ B₀, M.Base B₀ ∧ ⇑f '' B = ⇑f '' B₀
tactic: rw [Matroid.mapEmbedding, map_base_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α ↪ β
⊢ ∃ B₀, M.Base B₀ ∧ ⇑f '' B = ⇑f '' B₀
state_after: no goals
tactic: exact ⟨B, hB, rfl⟩
Theorem: List.argmax_mem
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f : α → β
l : List α
o : Option α
a m✝ m : α
⊢ m ∈ argmax f [] → m ∈ []
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f : α → β
l : List α
o : Option α
a m✝ hd : α
tl : List α
m : α
⊢ m ∈ argmax f (hd :: tl) → m ∈ hd :: tl
state_after: no goals
tactic: simpa [argmax, argAux] using foldl_argAux_mem _ tl hd m
Theorem: Equiv.Perm.IsCycle.existsUnique_cycle_subtype
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
f : Perm α
hf : f.IsCycle
⊢ ∃! s, (↑s).formPerm ⋯ = f
state_after: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
⊢ ∃! s_1, (↑s_1).formPerm ⋯ = s.formPerm hs
tactic: obtain ⟨s, ⟨hs, rfl⟩, hs'⟩ := hf.existsUnique_cycle
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
⊢ ∃! s_1, (↑s_1).formPerm ⋯ = s.formPerm hs
state_after: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
⊢ ∀ (y : { s // s.Nodup }), (fun s_1 => (↑s_1).formPerm ⋯ = s.formPerm hs) y → y = ⟨s, hs⟩
tactic: refine ⟨⟨s, hs⟩, rfl, ?_⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
⊢ ∀ (y : { s // s.Nodup }), (fun s_1 => (↑s_1).formPerm ⋯ = s.formPerm hs) y → y = ⟨s, hs⟩
state_after: case intro.intro.intro.mk
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
t : Cycle α
ht : t.Nodup
ht' : (↑⟨t, ht⟩).formPerm ⋯ = s.formPerm hs
⊢ ⟨t, ht⟩ = ⟨s, hs⟩
tactic: rintro ⟨t, ht⟩ ht'
state_before: case intro.intro.intro.mk
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
hf : (s.formPerm hs).IsCycle
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ (h : s_1.Nodup), s_1.formPerm h = s.formPerm hs) y → y = s
t : Cycle α
ht : t.Nodup
ht' : (↑⟨t, ht⟩).formPerm ⋯ = s.formPerm hs
⊢ ⟨t, ht⟩ = ⟨s, hs⟩
state_after: no goals
tactic: simpa using hs' _ ⟨ht, ht'⟩
Theorem: CategoryTheory.Functor.map_dite
File: Mathlib/CategoryTheory/Functor/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F : C ⥤ D
X Y : C
P : Prop
inst✝ : Decidable P
f : P → (X ⟶ Y)
g : ¬P → (X ⟶ Y)
⊢ F.map (if h : P then f h else g h) = if h : P then F.map (f h) else F.map (g h)
state_after: no goals
tactic: aesop_cat
Theorem: ComplexShape.Embedding.r_eq_some
File: Mathlib/Algebra/Homology/Embedding/Basic.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
⊢ e.r i' = some i
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
⊢ e.r i' = some i
tactic: have h : ∃ (i : ι), e.f i = i' := ⟨i, hi⟩
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
⊢ e.r i' = some i
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
this : h.choose = i
⊢ e.r i' = some i
tactic: have : h.choose = i := e.injective_f (h.choose_spec.trans (hi.symm))
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
this : h.choose = i
⊢ e.r i' = some i
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
this : h.choose = i
⊢ (if h : ∃ i, e.f i = i' then some h.choose else none) = some i
tactic: dsimp [r]
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
this : h.choose = i
⊢ (if h : ∃ i, e.f i = i' then some h.choose else none) = some i
state_after: no goals
tactic: rw [dif_pos ⟨i, hi⟩, this]
Theorem: Complex.exists_root
File: Mathlib/Analysis/Complex/Polynomial/Basic.lean

Proof steps:
state_before: f : ℂ[X]
hf : 0 < f.degree
⊢ ∃ z, f.IsRoot z
state_after: f : ℂ[X]
hf : 0 < f.degree
hf' : ∀ (z : ℂ), ¬f.IsRoot z
⊢ False
tactic: by_contra! hf'
state_before: f : ℂ[X]
hf : 0 < f.degree
hf' : ∀ (z : ℂ), ¬f.IsRoot z
⊢ False
state_after: f : ℂ[X]
hf : 0 < f.degree
hf' : ∀ (z : ℂ), ¬f.IsRoot z
this : ∀ (z : ℂ), (eval z f)⁻¹ = 0
⊢ False
tactic: have (z : ℂ) : (f.eval z)⁻¹ = 0 :=
    (f.differentiable.inv hf').apply_eq_of_tendsto_cocompact z <|
      Metric.cobounded_eq_cocompact (α := ℂ) ▸ (Filter.tendsto_inv₀_cobounded.comp <| by
        simpa only [tendsto_norm_atTop_iff_cobounded]
          using f.tendsto_norm_atTop hf tendsto_norm_cobounded_atTop)
state_before: f : ℂ[X]
hf : 0 < f.degree
hf' : ∀ (z : ℂ), ¬f.IsRoot z
this : ∀ (z : ℂ), (eval z f)⁻¹ = 0
⊢ False
state_after: hf : 0 < (C 0).degree
hf' : ∀ (z : ℂ), ¬(C 0).IsRoot z
this : ∀ (z : ℂ), (eval z (C 0))⁻¹ = 0
⊢ False
tactic: obtain rfl : f = C 0 := Polynomial.funext fun z ↦ inv_injective <| by simp [this]
state_before: hf : 0 < (C 0).degree
hf' : ∀ (z : ℂ), ¬(C 0).IsRoot z
this : ∀ (z : ℂ), (eval z (C 0))⁻¹ = 0
⊢ False
state_after: no goals
tactic: simp at hf
Theorem: HomologicalComplex.d_comp_XIsoOfEq_hom
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₂ p₃ : ι
h : p₂ = p₃
p₁ : ι
⊢ K.d p₁ p₂ ≫ (K.XIsoOfEq h).hom = K.d p₁ p₃
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₂ p₁ : ι
⊢ K.d p₁ p₂ ≫ (K.XIsoOfEq ⋯).hom = K.d p₁ p₂
tactic: subst h
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₂ p₁ : ι
⊢ K.d p₁ p₂ ≫ (K.XIsoOfEq ⋯).hom = K.d p₁ p₂
state_after: no goals
tactic: simp