ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.le_arcsin_iff_sin_le'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
hx : x ∈ Ioc (-(π / 2)) (π / 2)
⊢ x ≤ arcsin y ↔ sin x ≤ y
state_after: no goals
tactic: rw [← neg_le_neg_iff, ← arcsin_neg, arcsin_le_iff_le_sin' ⟨neg_le_neg hx.2, neg_lt.2 hx.1⟩,
    sin_neg, neg_le_neg_iff]
Theorem: Complex.angle_div_right_eq_angle_mul_left
File: Mathlib/Analysis/Complex/Angle.lean

Proof steps:
state_before: a✝ x✝ y✝ a x y : ℂ
⊢ angle x (y / a) = angle (x * a) y
state_after: no goals
tactic: rw [angle_comm, angle_div_left_eq_angle_mul_right, angle_comm]
Theorem: Finset.sup_le_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ s.sup f ≤ a ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
tactic: apply Iff.trans Multiset.sup_le
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
state_after: no goals
tactic: exact ⟨fun k b hb => k _ _ hb rfl, fun k a' b hb h => h ▸ k _ hb⟩
Theorem: CategoryTheory.Pretriangulated.Triangle.isZero₁_of_isZero₂₃
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₂ : IsZero T.obj₂
h₃ : IsZero T.obj₃
⊢ IsZero T.obj₁
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₂ : IsZero T.obj₂
h₃ : IsZero T.obj₃
⊢ T.mor₁ = 0 ∧ T.mor₃ = 0
tactic: rw [T.isZero₁_iff hT]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
h₂ : IsZero T.obj₂
h₃ : IsZero T.obj₃
⊢ T.mor₁ = 0 ∧ T.mor₃ = 0
state_after: no goals
tactic: exact ⟨h₂.eq_of_tgt _ _, h₃.eq_of_src _ _⟩
Theorem: Finset.Ico_inter_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
⊢ Ico a b ∩ Ico c d = Ico (max a c) (min b d)
state_after: no goals
tactic: rw [← coe_inj, coe_inter, coe_Ico, coe_Ico, coe_Ico, ← inf_eq_min, ← sup_eq_max,
    Set.Ico_inter_Ico]
Theorem: List.fst_lt_of_mem_enum
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : ℕ × α
l : List α
h : x ∈ l.enum
⊢ x.1 < l.length
state_after: no goals
tactic: simpa using fst_lt_add_of_mem_enumFrom h
Theorem: ZMod.exists_sq_eq_neg_two_iff
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ IsSquare (-2) ↔ p % 8 = 1 ∨ p % 8 = 3
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
tactic: rw [FiniteField.isSquare_neg_two_iff, card p]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 2 = 1
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
tactic: have h₁ := Prime.mod_two_eq_one_iff_ne_two.mpr hp
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 2 = 1
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
tactic: rw [← mod_mod_of_dvd p (by decide : 2 ∣ 8)] at h₁
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
h₂ : p % 8 < 8
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
tactic: have h₂ := mod_lt p (by norm_num : 0 < 8)
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
h₂ : p % 8 < 8
⊢ p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 % 2 = 1 → p % 8 < 8 → (p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3)
tactic: revert h₂ h₁
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 % 2 = 1 → p % 8 < 8 → (p % 8 ≠ 5 ∧ p % 8 ≠ 7 ↔ p % 8 = 1 ∨ p % 8 = 3)
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3)
tactic: generalize p % 8 = m
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3)
state_after: m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3)
tactic: clear! p
state_before: m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3)
state_after: m : ℕ
h₁✝ : m % 2 = 1
h₂✝ : m < 8
⊢ m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3
tactic: intros
state_before: m : ℕ
h₁✝ : m % 2 = 1
h₂✝ : m < 8
⊢ m ≠ 5 ∧ m ≠ 7 ↔ m = 1 ∨ m = 3
state_after: no goals
tactic: interval_cases m <;> simp_all
Theorem: AddMonoidHom.comp_coprod
File: Mathlib/Algebra/Group/Prod.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
f✝ : M →* P
g✝ : N →* P
Q : Type u_8
inst✝ : CommMonoid Q
h : P →* Q
f : M →* P
g : N →* P
x : M × N
⊢ (h.comp (f.coprod g)) x = ((h.comp f).coprod (h.comp g)) x
state_after: no goals
tactic: simp
Theorem: LieAlgebra.InvariantForm.orthogonal_isCompl_coe_submodule
File: Mathlib/Algebra/Lie/InvariantForm.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : Field K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : AddCommGroup M
inst✝² : Module K M
inst✝¹ : LieRingModule L M
inst✝ : Module.Finite K L
Φ : LinearMap.BilinForm K L
hΦ_nondeg : Φ.Nondegenerate
hΦ_inv : LinearMap.BilinForm.lieInvariant L Φ
hΦ_refl : Φ.IsRefl
hL : ∀ (I : LieIdeal K L), IsAtom I → ¬IsLieAbelian ↥↑I
I : LieIdeal K L
hI : IsAtom I
⊢ IsCompl ↑I ↑(orthogonal Φ hΦ_inv I)
state_after: K : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : Field K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : AddCommGroup M
inst✝² : Module K M
inst✝¹ : LieRingModule L M
inst✝ : Module.Finite K L
Φ : LinearMap.BilinForm K L
hΦ_nondeg : Φ.Nondegenerate
hΦ_inv : LinearMap.BilinForm.lieInvariant L Φ
hΦ_refl : Φ.IsRefl
hL : ∀ (I : LieIdeal K L), IsAtom I → ¬IsLieAbelian ↥↑I
I : LieIdeal K L
hI : IsAtom I
⊢ Disjoint I (orthogonal Φ hΦ_inv I)
tactic: rw [orthogonal_toSubmodule, LinearMap.BilinForm.isCompl_orthogonal_iff_disjoint hΦ_refl,
      ← orthogonal_toSubmodule _ hΦ_inv, ← LieSubmodule.disjoint_iff_coe_toSubmodule]
state_before: K : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : Field K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : AddCommGroup M
inst✝² : Module K M
inst✝¹ : LieRingModule L M
inst✝ : Module.Finite K L
Φ : LinearMap.BilinForm K L
hΦ_nondeg : Φ.Nondegenerate
hΦ_inv : LinearMap.BilinForm.lieInvariant L Φ
hΦ_refl : Φ.IsRefl
hL : ∀ (I : LieIdeal K L), IsAtom I → ¬IsLieAbelian ↥↑I
I : LieIdeal K L
hI : IsAtom I
⊢ Disjoint I (orthogonal Φ hΦ_inv I)
state_after: no goals
tactic: exact orthogonal_disjoint Φ hΦ_nondeg hΦ_inv hL I hI
Theorem: CategoryTheory.essentiallySmall_of_small_of_locallySmall
File: Mathlib/CategoryTheory/EssentiallySmall.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Small.{w, u} C
inst✝ : LocallySmall.{w, v, u} C
⊢ LocallySmall.{w, v, u} C
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.ShortComplex.mapRightHomologyIso_inv_naturality
File: Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁹ : Category.{u_3, u_1} C
inst✝⁸ : Category.{u_4, u_2} D
inst✝⁷ : HasZeroMorphisms C
inst✝⁶ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : S.LeftHomologyData
h₂✝ : S.RightHomologyData
F✝ : C ⥤ D
inst✝⁵ : F✝.PreservesZeroMorphisms
hl : S.LeftHomologyData
hr : S.RightHomologyData
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : S₁.LeftHomologyData
hr₁ : S₁.RightHomologyData
hl₂ : S₂.LeftHomologyData
hr₂ : S₂.RightHomologyData
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
F : C ⥤ D
inst✝⁴ : F.PreservesZeroMorphisms
inst✝³ : S₁.HasRightHomology
inst✝² : S₂.HasRightHomology
inst✝¹ : F.PreservesRightHomologyOf S₁
inst✝ : F.PreservesRightHomologyOf S₂
⊢ F.map (rightHomologyMap φ) ≫ (S₂.mapRightHomologyIso F).inv =
    (S₁.mapRightHomologyIso F).inv ≫ rightHomologyMap (F.mapShortComplex.map φ)
state_after: no goals
tactic: rw [← cancel_epi (S₁.mapRightHomologyIso F).hom, ← mapRightHomologyIso_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
Theorem: Matrix.PosSemidef.add
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ (A + B) *ᵥ x
state_after: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x
tactic: rw [add_mulVec, dotProduct_add]
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A B : Matrix m m R
hA : A.PosSemidef
hB : B.PosSemidef
x : m → R
⊢ 0 ≤ star x ⬝ᵥ A *ᵥ x + star x ⬝ᵥ B *ᵥ x
state_after: no goals
tactic: exact add_nonneg (hA.2 x) (hB.2 x)
Theorem: Nat.pair_lt_pair_left
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: a₁ a₂ b : ℕ
h : a₁ < a₂
⊢ pair a₁ b < pair a₂ b
state_after: case pos
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
⊢ b * b + a₁ < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)

case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : ¬a₁ < b
⊢ a₁ * a₁ + (a₁ + b) < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)
tactic: by_cases h₁ : a₁ < b <;> simp [pair, h₁, Nat.add_assoc]
Theorem: Polynomial.splits_of_splits_of_dvd
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf0 : f ≠ 0
hf : Splits i f
hgf : g ∣ f
⊢ Splits i g
state_after: case intro
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
g f : K[X]
hf0 : g * f ≠ 0
hf : Splits i (g * f)
⊢ Splits i g
tactic: obtain ⟨f, rfl⟩ := hgf
state_before: case intro
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
g f : K[X]
hf0 : g * f ≠ 0
hf : Splits i (g * f)
⊢ Splits i g
state_after: no goals
tactic: exact (splits_of_splits_mul i hf0 hf).1
Theorem: CategoryTheory.epi_iff_isPushout
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
⊢ Epi f ↔ IsPushout f f (𝟙 Y) (𝟙 Y)
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
⊢ Epi f → IsPushout f f (𝟙 Y) (𝟙 Y)

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
⊢ IsPushout f f (𝟙 Y) (𝟙 Y) → Epi f
tactic: constructor
Theorem: AffineSubspace.pointwise_vadd_top
File: Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean

Proof steps:
state_before: k : Type u_1
inst✝⁹ : Ring k
V : Type u_2
P : Type u_3
V₁ : Type u_4
P₁ : Type u_5
V₂ : Type u_6
P₂ : Type u_7
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
v : V
⊢ v +ᵥ ⊤ = ⊤
state_after: case h
k : Type u_1
inst✝⁹ : Ring k
V : Type u_2
P : Type u_3
V₁ : Type u_4
P₁ : Type u_5
V₂ : Type u_6
P₂ : Type u_7
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
v : V
x✝ : P
⊢ x✝ ∈ v +ᵥ ⊤ ↔ x✝ ∈ ⊤
tactic: ext
state_before: case h
k : Type u_1
inst✝⁹ : Ring k
V : Type u_2
P : Type u_3
V₁ : Type u_4
P₁ : Type u_5
V₂ : Type u_6
P₂ : Type u_7
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
v : V
x✝ : P
⊢ x✝ ∈ v +ᵥ ⊤ ↔ x✝ ∈ ⊤
state_after: no goals
tactic: simp [pointwise_vadd_eq_map, map_top, vadd_eq_iff_eq_neg_vadd]
Theorem: Complex.div_I
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ -(z * I) * I = z
state_after: no goals
tactic: simp [mul_assoc]
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_of_gt
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.σ j.castSucc ≫ X.δ i.succ = X.δ i ≫ X.σ j
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.map (SimplexCategory.σ j.castSucc).op ≫ X.map (SimplexCategory.δ i.succ).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : j.castSucc < i
⊢ X.map (SimplexCategory.σ j.castSucc).op ≫ X.map (SimplexCategory.δ i.succ).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt H]
Theorem: Multiset.noncommFold_eq_fold
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
assoc : Std.Associative op
s : Multiset α
inst✝ : Std.Commutative op
a : α
⊢ noncommFold op s ⋯ a = fold op a s
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
assoc : Std.Associative op
inst✝ : Std.Commutative op
a : α
a✝ : List α
⊢ noncommFold op ⟦a✝⟧ ⋯ a = fold op a ⟦a✝⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
assoc : Std.Associative op
inst✝ : Std.Commutative op
a : α
a✝ : List α
⊢ noncommFold op ⟦a✝⟧ ⋯ a = fold op a ⟦a✝⟧
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MonoOver.congr_inverse
File: Mathlib/CategoryTheory/Subobject/MonoOver.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono ((Over.post e.functor).obj ((forget X).obj f)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono (e.functor.map f.arrow)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver X
⊢ Mono (e.functor.map f.arrow)
state_after: no goals
tactic: infer_instance
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono ((Over.post e.inverse).obj ((forget (e.functor.obj X)).obj f)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono (e.inverse.map f.arrow)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
f : MonoOver (e.functor.obj X)
⊢ Mono (e.inverse.map f.arrow)
state_after: no goals
tactic: infer_instance
Theorem: Real.Gamma_eq_integral
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℝ
hs : 0 < s
⊢ Gamma s = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
state_after: s : ℝ
hs : 0 < s
⊢ (↑s).GammaIntegral.re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
tactic: rw [Gamma, Complex.Gamma_eq_integral (by rwa [Complex.ofReal_re] : 0 < Complex.re s)]
state_before: s : ℝ
hs : 0 < s
⊢ (↑s).GammaIntegral.re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
state_after: s : ℝ
hs : 0 < s
⊢ (∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ (↑s - 1)).re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
tactic: dsimp only [Complex.GammaIntegral]
state_before: s : ℝ
hs : 0 < s
⊢ (∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ (↑s - 1)).re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
state_after: s : ℝ
hs : 0 < s
⊢ (∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ ↑(s - 1)).re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
tactic: simp_rw [← Complex.ofReal_one, ← Complex.ofReal_sub]
state_before: s : ℝ
hs : 0 < s
⊢ (∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ ↑(s - 1)).re = ∫ (x : ℝ) in Ioi 0, rexp (-x) * x ^ (s - 1)
state_after: s : ℝ
hs : 0 < s
⊢ ∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ ↑(s - 1) = ∫ (x : ℝ) in Ioi 0, ↑(rexp (-x) * x ^ (s - 1))
tactic: suffices ∫ x : ℝ in Ioi 0, ↑(exp (-x)) * (x : ℂ) ^ ((s - 1 : ℝ) : ℂ) =
      ∫ x : ℝ in Ioi 0, ((exp (-x) * x ^ (s - 1) : ℝ) : ℂ) by
    have cc : ∀ r : ℝ, Complex.ofReal' r = @RCLike.ofReal ℂ _ r := fun r => rfl
    conv_lhs => rw [this]; enter [1, 2, x]; rw [cc]
    rw [_root_.integral_ofReal, ← cc, Complex.ofReal_re]
state_before: s : ℝ
hs : 0 < s
⊢ ∫ (x : ℝ) in Ioi 0, ↑(rexp (-x)) * ↑x ^ ↑(s - 1) = ∫ (x : ℝ) in Ioi 0, ↑(rexp (-x) * x ^ (s - 1))
state_after: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ ↑(rexp (-x)) * ↑x ^ ↑(s - 1) = ↑(rexp (-x) * x ^ (s - 1))
tactic: refine setIntegral_congr measurableSet_Ioi fun x hx => ?_
state_before: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ ↑(rexp (-x)) * ↑x ^ ↑(s - 1) = ↑(rexp (-x) * x ^ (s - 1))
state_after: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑(x ^ (s - 1))
tactic: push_cast
state_before: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑(x ^ (s - 1))
state_after: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑x ^ ↑(s - 1)
tactic: rw [Complex.ofReal_cpow (le_of_lt hx)]
state_before: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑x ^ ↑(s - 1)
state_after: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑x ^ (↑s - 1)
tactic: push_cast
state_before: s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Ioi 0
⊢ Complex.exp (-↑x) * ↑x ^ (↑s - 1) = Complex.exp (-↑x) * ↑x ^ (↑s - 1)
state_after: no goals
tactic: rfl
Theorem: AnalyticAt.frequently_eq_iff_eventually_eq
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
hg : AnalyticAt 𝕜 g z₀
⊢ (∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z = g z) ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = g z
state_after: no goals
tactic: simpa [sub_eq_zero] using frequently_zero_iff_eventually_zero (hf.sub hg)
Theorem: MeasurableSpace.generateFrom_singleton_empty
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
⊢ ∀ t ∈ {∅}, MeasurableSet t
state_after: no goals
tactic: simp [@MeasurableSet.empty α ⊥]
Theorem: Ordinal.nfpFamily_fp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ f i (nfpFamily f a) = nfpFamily f a
state_after: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ f i (sup (List.foldr f a)) = sup (List.foldr f a)
tactic: unfold nfpFamily
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ f i (sup (List.foldr f a)) = sup (List.foldr f a)
state_after: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ sup (f i ∘ List.foldr f a) = sup (List.foldr f a)
tactic: rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ sup (f i ∘ List.foldr f a) = sup (List.foldr f a)
state_after: case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
l : List ι
⊢ (f i ∘ List.foldr f a) l ≤ sup (List.foldr f a)

case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
l : List ι
⊢ List.foldr f a l ≤ sup (f i ∘ List.foldr f a)
tactic: apply le_antisymm <;> refine Ordinal.sup_le fun l => ?_
Theorem: Cardinal.mul_le_max_of_aleph0_le_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
⊢ a * b ≤ max a b
state_after: case h.e'_4
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
⊢ max a b = max a b * max a b
tactic: convert mul_le_mul' (le_max_left a b) (le_max_right a b) using 1
state_before: case h.e'_4
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
⊢ max a b = max a b * max a b
state_after: case h.e'_4
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
⊢ ℵ₀ ≤ max a b
tactic: rw [mul_eq_self]
state_before: case h.e'_4
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
⊢ ℵ₀ ≤ max a b
state_after: no goals
tactic: exact h.trans (le_max_left a b)