ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: tangentCone_mono
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
h : s ⊆ t
⊢ tangentConeAt 𝕜 s x ⊆ tangentConeAt 𝕜 t x
state_after: case intro.intro.intro.intro
𝕜 : 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
h : s ⊆ t
y : E
c : ℕ → 𝕜
d : ℕ → E
ds : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
ctop : Tendsto (fun n => ‖c n‖) atTop atTop
clim : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ tangentConeAt 𝕜 t x
tactic: rintro y ⟨c, d, ds, ctop, clim⟩
state_before: case intro.intro.intro.intro
𝕜 : 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
h : s ⊆ t
y : E
c : ℕ → 𝕜
d : ℕ → E
ds : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
ctop : Tendsto (fun n => ‖c n‖) atTop atTop
clim : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ tangentConeAt 𝕜 t x
state_after: no goals
tactic: exact ⟨c, d, mem_of_superset ds fun n hn => h hn, ctop, clim⟩
Theorem: AlgebraicGeometry.isAffineHom_stableUnderBaseChange
File: Mathlib/AlgebraicGeometry/Morphisms/Affine.lean

Proof steps:
state_before: X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
⊢ MorphismProperty.StableUnderBaseChange @IsAffineHom
state_after: case hP'
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
⊢ AffineTargetMorphismProperty.StableUnderBaseChange fun X x x_1 x => IsAffine X
tactic: apply HasAffineProperty.stableUnderBaseChange
state_before: case hP'
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
⊢ AffineTargetMorphismProperty.StableUnderBaseChange fun X x x_1 x => IsAffine X
state_after: case hP'
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
⊢ AffineTargetMorphismProperty.StableUnderBaseChange fun X x x_1 x => IsAffine X
tactic: letI := HasAffineProperty.isLocal_affineProperty
state_before: case hP'
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
⊢ AffineTargetMorphismProperty.StableUnderBaseChange fun X x x_1 x => IsAffine X
state_after: case hP'.H
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
⊢ ∀ ⦃X Y S : Scheme⦄ [inst : IsAffine S] [inst : IsAffine X] (f : X ⟶ S) (g : Y ⟶ S),
    IsAffine Y → IsAffine (Limits.pullback f g)
tactic: apply AffineTargetMorphismProperty.StableUnderBaseChange.mk
state_before: case hP'.H
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
⊢ ∀ ⦃X Y S : Scheme⦄ [inst : IsAffine S] [inst : IsAffine X] (f : X ⟶ S) (g : Y ⟶ S),
    IsAffine Y → IsAffine (Limits.pullback f g)
state_after: case hP'.H
X✝¹ Y✝ Z : Scheme
f✝ : X✝¹ ⟶ Y✝
g✝ : Y✝ ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
X✝ Y S : Scheme
X : IsAffine S
hX : IsAffine X✝
f : X✝ ⟶ S
g : Y ⟶ S
H : IsAffine Y
⊢ IsAffine (Limits.pullback f g)
tactic: introv X hX H
state_before: case hP'.H
X✝¹ Y✝ Z : Scheme
f✝ : X✝¹ ⟶ Y✝
g✝ : Y✝ ⟶ Z
this : ∀ (P : MorphismProperty Scheme) {Q : outParam AffineTargetMorphismProperty} [self : HasAffineProperty P Q],
  AffineTargetMorphismProperty.IsLocal Q :=
  HasAffineProperty.isLocal_affineProperty
X✝ Y S : Scheme
X : IsAffine S
hX : IsAffine X✝
f : X✝ ⟶ S
g : Y ⟶ S
H : IsAffine Y
⊢ IsAffine (Limits.pullback f g)
state_after: no goals
tactic: infer_instance
Theorem: AlgebraicGeometry.isAffine_of_isIso
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
h : IsAffine Y
⊢ IsAffine X
state_after: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
h : Y ∈ Scheme.Spec.essImage
⊢ X ∈ Scheme.Spec.essImage
tactic: rw [← mem_Spec_essImage] at h ⊢
state_before: X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
h : Y ∈ Scheme.Spec.essImage
⊢ X ∈ Scheme.Spec.essImage
state_after: no goals
tactic: exact Functor.essImage.ofIso (asIso f).symm h
Theorem: FirstOrder.Language.Embedding.ofInjective_toHom
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝⁴ : L.Structure M
inst✝³ : L.Structure N
P : Type u_1
inst✝² : L.Structure P
Q : Type u_2
inst✝¹ : L.Structure Q
inst✝ : L.IsAlgebraic
f : M →[L] N
hf : Function.Injective ⇑f
⊢ (ofInjective hf).toHom = f
state_after: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝⁴ : L.Structure M
inst✝³ : L.Structure N
P : Type u_1
inst✝² : L.Structure P
Q : Type u_2
inst✝¹ : L.Structure Q
inst✝ : L.IsAlgebraic
f : M →[L] N
hf : Function.Injective ⇑f
x✝ : M
⊢ (ofInjective hf).toHom x✝ = f x✝
tactic: ext
state_before: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝⁴ : L.Structure M
inst✝³ : L.Structure N
P : Type u_1
inst✝² : L.Structure P
Q : Type u_2
inst✝¹ : L.Structure Q
inst✝ : L.IsAlgebraic
f : M →[L] N
hf : Function.Injective ⇑f
x✝ : M
⊢ (ofInjective hf).toHom x✝ = f x✝
state_after: no goals
tactic: simp
Theorem: lipschitzOnWith_iff_norm_sub_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
⊢ LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x / f y‖ ≤ ↑C * ‖x / y‖
state_after: no goals
tactic: simp only [lipschitzOnWith_iff_dist_le_mul, dist_eq_norm_div]
Theorem: NonUnitalSubring.coe_eq_zero_iff
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocRing R
inst✝¹ : NonUnitalNonAssocRing S
inst✝ : NonUnitalNonAssocRing T
s : NonUnitalSubring R
x : ↥s
⊢ ↑x = 0 ↔ x = 0
state_after: no goals
tactic: simp
Theorem: Fintype.card_subtype_lt
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
hx : ¬p x
⊢ x ∉ Set.range Subtype.val
state_after: no goals
tactic: rwa [Subtype.range_coe_subtype]
Theorem: CategoryTheory.Monad.algebraEquivOfIsoMonads_inverse
File: Mathlib/CategoryTheory/Monad/Algebra.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T T₁ T₂ : Monad C
h : T₁ ≅ T₂
⊢ 𝟙 T₁ = h.hom ≫ h.inv
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T T₁ T₂ : Monad C
h : T₁ ≅ T₂
⊢ h.inv ≫ h.hom = 𝟙 T₂
state_after: no goals
tactic: simp
Theorem: AddConstMapClass.map_int_add'
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddCommGroupWithOne G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H 1 b
f : F
n : ℤ
x : G
⊢ f (↑n + x) = f x + n • b
state_after: no goals
tactic: rw [← map_zsmul_add, zsmul_one]
Theorem: CategoryTheory.isCodetector_iff_reflectsIsomorphisms_yoneda_obj
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
⊢ IsCodetector G ↔ (yoneda.obj G).ReflectsIsomorphisms
state_after: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
hG : IsCodetector G
A✝ B✝ : Cᵒᵖ
f : A✝ ⟶ B✝
hf : IsIso ((yoneda.obj G).map f)
⊢ IsIso f

case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
h : (yoneda.obj G).ReflectsIsomorphisms
X Y : C
f : X ⟶ Y
hf : ∀ (h : X ⟶ G), ∃! h', f ≫ h' = h
⊢ IsIso f
tactic: refine ⟨fun hG => ⟨fun f hf => ?_⟩, fun h => (isCodetector_def _).2 fun X Y f hf => ?_⟩
Theorem: Metric.subsingleton_closedBall
File: Mathlib/Topology/MetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
r : ℝ
hr : r ≤ 0
⊢ (closedBall x r).Subsingleton
state_after: case inl
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
r : ℝ
hr✝ : r ≤ 0
hr : r < 0
⊢ (closedBall x r).Subsingleton

case inr
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x✝ : γ
s : Set γ
x : γ
hr : 0 ≤ 0
⊢ (closedBall x 0).Subsingleton
tactic: rcases hr.lt_or_eq with (hr | rfl)
Theorem: List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ ys : List M
⊢ [].prod * ys.prod = (zipWith (fun x x_1 => x * x_1) [] ys).prod * (drop ys.length []).prod * (drop [].length ys).prod
state_after: no goals
tactic: simp [Nat.zero_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ xs : List M
⊢ xs.prod * [].prod = (zipWith (fun x x_1 => x * x_1) xs []).prod * (drop [].length xs).prod * (drop xs.length []).prod
state_after: no goals
tactic: simp [Nat.zero_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ (x :: xs).prod * (y :: ys).prod =
    (zipWith (fun x x_1 => x * x_1) (x :: xs) (y :: ys)).prod * (drop (y :: ys).length (x :: xs)).prod *
      (drop (x :: xs).length (y :: ys)).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * xs.prod * (y * ys.prod) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
tactic: simp only [drop, length, zipWith_cons_cons, prod_cons]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * xs.prod * (y * ys.prod) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * (y * ((zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod)) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
tactic: conv =>
      lhs; rw [mul_assoc]; right; rw [mul_comm, mul_assoc]; right
      rw [mul_comm, prod_mul_prod_eq_prod_zipWith_mul_prod_drop xs ys]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l l₁ l₂ : List M
x : M
xs : List M
y : M
ys : List M
⊢ x * (y * ((zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod)) =
    x * y * (zipWith (fun x x_1 => x * x_1) xs ys).prod * (drop ys.length xs).prod * (drop xs.length ys).prod
state_after: no goals
tactic: simp [mul_assoc]
Theorem: OrderIso.mulLeft₀'_symm
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
⊢ (mulLeft₀' ha).symm = mulLeft₀' ⋯
state_after: case h.h
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
x✝ : α
⊢ (mulLeft₀' ha).symm x✝ = (mulLeft₀' ⋯) x✝
tactic: ext
state_before: case h.h
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
x✝ : α
⊢ (mulLeft₀' ha).symm x✝ = (mulLeft₀' ⋯) x✝
state_after: no goals
tactic: rfl
Theorem: codisjoint_inf_right
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderTop α
a b c : α
⊢ Codisjoint a (b ⊓ c) ↔ Codisjoint a b ∧ Codisjoint a c
state_after: no goals
tactic: simp only [codisjoint_iff, sup_inf_left, inf_eq_top_iff]
Theorem: List.prod_toFinset
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
x✝ : [].Nodup
⊢ [].toFinset.prod f = (map f []).prod
state_after: no goals
tactic: simp
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl : (a :: l).Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl✝ : (a :: l).Nodup
not_mem : a ∉ l
hl : l.Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
tactic: let ⟨not_mem, hl⟩ := List.nodup_cons.mp hl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl✝ : (a :: l).Nodup
not_mem : a ∉ l
hl : l.Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
state_after: no goals
tactic: simp [Finset.prod_insert (mt List.mem_toFinset.mp not_mem), prod_toFinset _ hl]
Theorem: CategoryTheory.CostructuredArrow.homMk'_comp
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ mk (S.map (g' ≫ g) ≫ f.hom) = mk (S.map g' ≫ (mk (S.map g ≫ f.hom)).hom)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ f.homMk' (g' ≫ g) = eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ (f.homMk' (g' ≫ g)).left = (eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g).left
tactic: ext
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ (f.homMk' (g' ≫ g)).left = (eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g).left
state_after: no goals
tactic: simp [eqToHom_left]
Theorem: ZFSet.toSet_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x : ZFSet
h : x.Nonempty
⊢ (⋂₀ x).toSet = ⋂₀ (toSet '' x.toSet)
state_after: case h
x : ZFSet
h : x.Nonempty
x✝ : ZFSet
⊢ x✝ ∈ (⋂₀ x).toSet ↔ x✝ ∈ ⋂₀ (toSet '' x.toSet)
tactic: ext
state_before: case h
x : ZFSet
h : x.Nonempty
x✝ : ZFSet
⊢ x✝ ∈ (⋂₀ x).toSet ↔ x✝ ∈ ⋂₀ (toSet '' x.toSet)
state_after: no goals
tactic: simp [mem_sInter h]
Theorem: dist_self_div_left
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist (a / b) a = ‖b‖
state_after: no goals
tactic: rw [dist_comm, dist_self_div_right]
Theorem: DFinsupp.filter_ne_eq_erase
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i : ι
⊢ filter (fun x => x ≠ i) f = erase i f
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i j : ι
⊢ (filter (fun x => x ≠ i) f) j = (erase i f) j
tactic: ext1 j
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i j : ι
⊢ (filter (fun x => x ≠ i) f) j = (erase i f) j
state_after: no goals
tactic: simp only [DFinsupp.filter_apply, DFinsupp.erase_apply, ite_not]
Theorem: toMatrix_distrib_mul_action_toLinearMap
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
x : R
⊢ (toMatrix v₁ v₁) (DistribMulAction.toLinearMap R M₁ x) = Matrix.diagonal fun x_1 => x
state_after: case a
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
x : R
i✝ j✝ : n
⊢ (toMatrix v₁ v₁) (DistribMulAction.toLinearMap R M₁ x) i✝ j✝ = Matrix.diagonal (fun x_1 => x) i✝ j✝
tactic: ext
state_before: case a
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
x : R
i✝ j✝ : n
⊢ (toMatrix v₁ v₁) (DistribMulAction.toLinearMap R M₁ x) i✝ j✝ = Matrix.diagonal (fun x_1 => x) i✝ j✝
state_after: no goals
tactic: rw [LinearMap.toMatrix_apply, DistribMulAction.toLinearMap_apply, LinearEquiv.map_smul,
    Basis.repr_self, Finsupp.smul_single_one, Finsupp.single_eq_pi_single, Matrix.diagonal_apply,
    Pi.single_apply]
Theorem: Complex.hasSum_sinh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean

Proof steps:
state_before: z : ℂ
⊢ HasSum (fun n => z ^ (2 * n + 1) / ↑(2 * n + 1)!) (sinh z)
state_after: no goals
tactic: simpa [mul_assoc, sin_mul_I, neg_pow z, pow_add, pow_mul, neg_mul, neg_div]
    using (hasSum_sin' (z * I)).mul_right (-I)
Theorem: IsAssociatedPrime.annihilator_le
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
I J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
h : IsAssociatedPrime I M
⊢ ⊤.annihilator ≤ I
state_after: case intro.intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
x : M
hI : (Submodule.span R {x}).annihilator.IsPrime
⊢ ⊤.annihilator ≤ (Submodule.span R {x}).annihilator
tactic: obtain ⟨hI, x, rfl⟩ := h
state_before: case intro.intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
x : M
hI : (Submodule.span R {x}).annihilator.IsPrime
⊢ ⊤.annihilator ≤ (Submodule.span R {x}).annihilator
state_after: no goals
tactic: exact Submodule.annihilator_mono le_top
Theorem: Nat.sub_eq_psub
File: Mathlib/Data/Nat/PSub.lean

Proof steps:
state_before: m n : ℕ
⊢ (m - n).ppred.getD 0 = (m.psub (n + 1)).getD 0
state_after: m n : ℕ
⊢ ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0
tactic: rw [sub_eq_psub m n, psub]
state_before: m n : ℕ
⊢ ((m.psub n).getD 0).ppred.getD 0 = (m.psub n >>= ppred).getD 0
state_after: no goals
tactic: cases psub m n <;> rfl
Theorem: summable_sum_mul_antidiagonal_of_summable_mul
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
A : Type u_5
inst✝⁵ : AddCommMonoid A
inst✝⁴ : HasAntidiagonal A
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : A → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f x.1 * g x.2
⊢ Summable fun n => ∑ kl ∈ antidiagonal n, f kl.1 * g kl.2
state_after: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
A : Type u_5
inst✝⁵ : AddCommMonoid A
inst✝⁴ : HasAntidiagonal A
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : A → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f (↑x.snd).1 * g (↑x.snd).2
⊢ Summable fun n => ∑ kl ∈ antidiagonal n, f kl.1 * g kl.2
tactic: rw [summable_mul_prod_iff_summable_mul_sigma_antidiagonal] at h
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
A : Type u_5
inst✝⁵ : AddCommMonoid A
inst✝⁴ : HasAntidiagonal A
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : A → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f (↑x.snd).1 * g (↑x.snd).2
⊢ Summable fun n => ∑ kl ∈ antidiagonal n, f kl.1 * g kl.2
state_after: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
A : Type u_5
inst✝⁵ : AddCommMonoid A
inst✝⁴ : HasAntidiagonal A
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : A → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f (↑x.snd).1 * g (↑x.snd).2
⊢ Summable fun x => ∑' (b : ↑↑(antidiagonal x)), f (↑b).1 * g (↑b).2
tactic: conv => congr; ext; rw [← Finset.sum_finset_coe, ← tsum_fintype]
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
A : Type u_5
inst✝⁵ : AddCommMonoid A
inst✝⁴ : HasAntidiagonal A
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : A → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f (↑x.snd).1 * g (↑x.snd).2
⊢ Summable fun x => ∑' (b : ↑↑(antidiagonal x)), f (↑b).1 * g (↑b).2
state_after: no goals
tactic: exact h.sigma' fun n ↦ (hasSum_fintype _).summable
Theorem: Set.Finite.toFinset_ssubset
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t✝ : Set α
a : α
hs : s.Finite
ht : t✝.Finite
t : Finset α
⊢ hs.toFinset ⊂ t ↔ s ⊂ ↑t
state_after: no goals
tactic: rw [← Finset.coe_ssubset, Finite.coe_toFinset]