ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: map_rootsOfUnity_eq_pow_self
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁶ : CommMonoid M
inst✝⁵ : CommMonoid N
inst✝⁴ : DivisionCommMonoid G
k l : ℕ+
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F R R
inst✝ : RingHomClass F R R
σ : F
ζ : ↥(rootsOfUnity k R)
⊢ ∃ m, σ ↑↑ζ = ↑↑ζ ^ m
state_after: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁶ : CommMonoid M
inst✝⁵ : CommMonoid N
inst✝⁴ : DivisionCommMonoid G
k l : ℕ+
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F R R
inst✝ : RingHomClass F R R
σ : F
ζ : ↥(rootsOfUnity k R)
m : ℤ
hm : ∀ (g : ↥(rootsOfUnity k R)), (restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m, σ ↑↑ζ = ↑↑ζ ^ m
tactic: obtain ⟨m, hm⟩ := MonoidHom.map_cyclic (restrictRootsOfUnity σ k)
state_before: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁶ : CommMonoid M
inst✝⁵ : CommMonoid N
inst✝⁴ : DivisionCommMonoid G
k l : ℕ+
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F R R
inst✝ : RingHomClass F R R
σ : F
ζ : ↥(rootsOfUnity k R)
m : ℤ
hm : ∀ (g : ↥(rootsOfUnity k R)), (restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m, σ ↑↑ζ = ↑↑ζ ^ m
state_after: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁶ : CommMonoid M
inst✝⁵ : CommMonoid N
inst✝⁴ : DivisionCommMonoid G
k l : ℕ+
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F R R
inst✝ : RingHomClass F R R
σ : F
ζ : ↥(rootsOfUnity k R)
m : ℤ
hm : ∀ (g : ↥(rootsOfUnity k R)), (restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m_1, ↑↑ζ ^ (m % ↑(orderOf ζ)).toNat = ↑↑ζ ^ m_1
tactic: rw [← restrictRootsOfUnity_coe_apply, hm, ← zpow_mod_orderOf, ← Int.toNat_of_nonneg
      (m.emod_nonneg (Int.natCast_ne_zero.mpr (pos_iff_ne_zero.mp (orderOf_pos ζ)))),
    zpow_natCast, rootsOfUnity.coe_pow]
state_before: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁶ : CommMonoid M
inst✝⁵ : CommMonoid N
inst✝⁴ : DivisionCommMonoid G
k l : ℕ+
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F R R
inst✝ : RingHomClass F R R
σ : F
ζ : ↥(rootsOfUnity k R)
m : ℤ
hm : ∀ (g : ↥(rootsOfUnity k R)), (restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m_1, ↑↑ζ ^ (m % ↑(orderOf ζ)).toNat = ↑↑ζ ^ m_1
state_after: no goals
tactic: exact ⟨(m % orderOf ζ).toNat, rfl⟩
Theorem: Multiset.coe_count
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s : Multiset α
a : α
l : List α
⊢ List.countP (fun b => decide (b = a)) l = List.countP (fun x => x == a) l
state_after: no goals
tactic: rfl
Theorem: semiconjBy_star_star_star
File: Mathlib/Algebra/Star/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Mul R
inst✝ : StarMul R
x y z : R
⊢ SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z
state_after: no goals
tactic: simp_rw [SemiconjBy, ← star_mul, star_inj, eq_comm]
Theorem: Asymptotics.IsBigO.exists_mem_basis
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Sort u_17
p : ι → Prop
s : ι → Set α
h✝ : f =O[l] g'
hb : l.HasBasis p s
c : ℝ
h : c > 0 ∧ IsBigOWith c l f g'
⊢ c > 0 ∧ ∃ i, p i ∧ ∀ x ∈ s i, ‖f x‖ ≤ c * ‖g' x‖
state_after: no goals
tactic: simpa only [isBigOWith_iff, hb.eventually_iff, exists_prop] using h
Theorem: AddSubgroup.finiteIndex_of_leftCoset_cover_const
File: Mathlib/GroupTheory/CosetCover.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : ⋃ i ∈ s, g i • ↑H = Set.univ
⊢ H.FiniteIndex
state_after: G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : Set.SurjOn (fun x => ↑(g x)) (↑s) Set.univ
⊢ H.FiniteIndex
tactic: simp_rw [leftCoset_cover_const_iff_surjOn] at hcovers
state_before: G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : Set.SurjOn (fun x => ↑(g x)) (↑s) Set.univ
⊢ H.FiniteIndex
state_after: G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : Set.SurjOn (fun x => ↑(g x)) (↑s) Set.univ
this : Finite (G ⧸ H)
⊢ H.FiniteIndex
tactic: have := Set.finite_univ_iff.mp <| Set.Finite.of_surjOn _ hcovers s.finite_toSet
state_before: G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : Set.SurjOn (fun x => ↑(g x)) (↑s) Set.univ
this : Finite (G ⧸ H)
⊢ H.FiniteIndex
state_after: no goals
tactic: exact H.finiteIndex_of_finite_quotient
Theorem: Monoid.PushoutI.NormalWord.prod_base_smul
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
h : H
w : NormalWord d
⊢ (h • w).prod = (base φ) h * w.prod
state_after: no goals
tactic: simp only [base_smul_def', prod, map_mul, mul_assoc]
Theorem: Function.invFunOn_image_image_subset
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
⊢ invFunOn f s '' (f '' s) ⊆ s
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
x : α
hx : x ∈ s
⊢ invFunOn f s (f x) ∈ s
tactic: rintro _ ⟨_, ⟨x,hx,rfl⟩, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t : Set β
f✝ : α → β
inst✝ : Nonempty α
f : α → β
s : Set α
x : α
hx : x ∈ s
⊢ invFunOn f s (f x) ∈ s
state_after: no goals
tactic: exact invFunOn_apply_mem hx
Theorem: Function.Involutive.ite_not
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u
f : α → α
h : Involutive f
P : Prop
inst✝ : Decidable P
x : α
⊢ f (if P then x else f x) = if ¬P then x else f x
state_after: no goals
tactic: rw [apply_ite f, h, ite_not]
Theorem: Polynomial.X_pow_sub_C_ne_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ X ^ n - C a ≠ 0
state_after: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ X ^ n + C (-a) ≠ 0
tactic: rw [sub_eq_add_neg, ← map_neg C a]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ X ^ n + C (-a) ≠ 0
state_after: no goals
tactic: exact X_pow_add_C_ne_zero hn _
Theorem: SimpleGraph.TripartiteFromTriangles.toTriangle_is3Clique
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (graph t).IsNClique 3 (toTriangle x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (∃ c, (x.1, x.2.1, c) ∈ t) ∧ (∃ b, (x.1, b, x.2.2) ∈ t) ∧ ∃ a, (a, x.2.1, x.2.2) ∈ t
tactic: simp only [toTriangle_apply, is3Clique_triple_iff, in₀₁_iff, in₀₂_iff, in₁₂_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (∃ c, (x.1, x.2.1, c) ∈ t) ∧ (∃ b, (x.1, b, x.2.2) ∈ t) ∧ ∃ a, (a, x.2.1, x.2.2) ∈ t
state_after: no goals
tactic: exact ⟨⟨_, hx⟩, ⟨_, hx⟩, _, hx⟩
Theorem: Prime.dvd_of_dvd_pow
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h : p ∣ a ^ n
⊢ p ∣ a
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
h : p ∣ a ^ 0
⊢ p ∣ a

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a ^ (n + 1)
⊢ p ∣ a
tactic: induction' n with n ih
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a ^ (n + 1)
⊢ p ∣ a
state_after: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
⊢ p ∣ a
tactic: rw [pow_succ'] at h
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
⊢ p ∣ a
state_after: case succ.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
dvd_a : p ∣ a
⊢ p ∣ a

case succ.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
dvd_pow : p ∣ a ^ n
⊢ p ∣ a
tactic: cases' dvd_or_dvd hp h with dvd_a dvd_pow
state_before: case succ.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
dvd_pow : p ∣ a ^ n
⊢ p ∣ a
state_after: no goals
tactic: exact ih dvd_pow
Theorem: Submodule.span_attach_biUnion
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
x : M
p p' : Submodule R M
inst✝⁵ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R₂ M₂
F : Type u_8
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝ : DecidableEq M
α : Type u_9
s : Finset α
f : { x // x ∈ s } → Finset M
⊢ span R ↑(s.attach.biUnion f) = ⨆ x, span R ↑(f x)
state_after: no goals
tactic: simp [span_iUnion]
Theorem: CategoryTheory.Limits.isLimitConeLeftOpOfCocone_lift
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.leftOp
j : Jᵒᵖ
⊢ ((fun s => (hc.desc (coconeOfConeLeftOp s)).unop) s ≫ (coneLeftOpOfCocone c).π.app j).op = (s.π.app j).op
state_after: no goals
tactic: simp only [coneLeftOpOfCocone_π_app, op_comp, Quiver.Hom.op_unop, IsColimit.fac,
        coconeOfConeLeftOp_ι_app, op_unop]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.leftOp
m : s.pt ⟶ (coneLeftOpOfCocone c).pt
w : ∀ (j : Jᵒᵖ), m ≫ (coneLeftOpOfCocone c).π.app j = s.π.app j
⊢ m = (fun s => (hc.desc (coconeOfConeLeftOp s)).unop) s
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.leftOp
m : s.pt ⟶ (coneLeftOpOfCocone c).pt
w : ∀ (j : Jᵒᵖ), m ≫ (coneLeftOpOfCocone c).π.app j = s.π.app j
j : J
⊢ (c.ι.app j ≫ m.op).unop = (c.ι.app j ≫ ((fun s => (hc.desc (coconeOfConeLeftOp s)).unop) s).op).unop
tactic: refine Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.leftOp
m : s.pt ⟶ (coneLeftOpOfCocone c).pt
w : ∀ (j : Jᵒᵖ), m ≫ (coneLeftOpOfCocone c).π.app j = s.π.app j
j : J
⊢ (c.ι.app j ≫ m.op).unop = (c.ι.app j ≫ ((fun s => (hc.desc (coconeOfConeLeftOp s)).unop) s).op).unop
state_after: no goals
tactic: simpa only [Quiver.Hom.op_unop, IsColimit.fac, coconeOfConeLeftOp_ι_app] using w (op j)
Theorem: SimplicialObject.Split.congr_f
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
S₁ S₂ : Split C
Φ₁ Φ₂ : S₁ ⟶ S₂
h : Φ₁ = Φ₂
n : ℕ
⊢ Φ₁.f n = Φ₂.f n
state_after: no goals
tactic: rw [h]
Theorem: Set.cons_mem_subchain_iff
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ a :: l ∈ s.subchain ↔ a ∈ s ∧ l ∈ s.subchain ∧ ∀ b ∈ l.head?, a < b
state_after: no goals
tactic: simp only [subchain, mem_setOf_eq, forall_mem_cons, chain'_cons', and_left_comm, and_comm,
    and_assoc]
Theorem: Real.rpow_eq_zero_iff_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
hx : 0 ≤ x
⊢ x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
state_after: x y z : ℝ
hx : 0 ≤ x
⊢ (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0
tactic: simp only [rpow_def_of_nonneg hx]
state_before: x y z : ℝ
hx : 0 ≤ x
⊢ (if x = 0 then if y = 0 then 1 else 0 else rexp (log x * y)) = 0 ↔ x = 0 ∧ y ≠ 0
state_after: no goals
tactic: split_ifs <;> simp [*, exp_ne_zero]
Theorem: hasProd_single
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b✝ : α
s : Finset β
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
this : HasProd f (∏ b' ∈ {b}, f b')
⊢ HasProd f (f b)
state_after: no goals
tactic: simpa using this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b✝ : α
s : Finset β
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∀ b_1 ∉ {b}, f b_1 = 1
state_after: no goals
tactic: simpa [hf]
Theorem: CategoryTheory.ProjectiveResolution.iso_inv_naturality
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ P.iso.inv ≫ (projectiveResolutions C).map f = (HomotopyCategory.quotient C (ComplexShape.down ℕ)).map φ ≫ Q.iso.inv
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ Homotopy (((projectiveResolution X).homotopyEquiv P).inv ≫ lift f (projectiveResolution X) (projectiveResolution Y))
    (φ ≫ ((projectiveResolution Y).homotopyEquiv Q).inv)
tactic: apply HomotopyCategory.eq_of_homotopy
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ Homotopy (((projectiveResolution X).homotopyEquiv P).inv ≫ lift f (projectiveResolution X) (projectiveResolution Y))
    (φ ≫ ((projectiveResolution Y).homotopyEquiv Q).inv)
state_after: case h.g_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ (((projectiveResolution X).homotopyEquiv P).inv ≫ lift f (projectiveResolution X) (projectiveResolution Y)) ≫
      (projectiveResolution Y).π =
    P.π ≫ (ChainComplex.single₀ C).map f

case h.h_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ (φ ≫ ((projectiveResolution Y).homotopyEquiv Q).inv) ≫ (projectiveResolution Y).π =
    P.π ≫ (ChainComplex.single₀ C).map f
tactic: apply liftHomotopy f
state_before: case h.g_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ (((projectiveResolution X).homotopyEquiv P).inv ≫ lift f (projectiveResolution X) (projectiveResolution Y)) ≫
      (projectiveResolution Y).π =
    P.π ≫ (ChainComplex.single₀ C).map f

case h.h_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ (φ ≫ ((projectiveResolution Y).homotopyEquiv Q).inv) ≫ (projectiveResolution Y).π =
    P.π ≫ (ChainComplex.single₀ C).map f
state_after: no goals
tactic: all_goals
    aesop_cat
Theorem: pow_lt_pow_right₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : 1 < a
hmn : m < n
⊢ a ^ m < a ^ n
state_after: case refl
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : 1 < a
⊢ a ^ m < a ^ m.succ

case step
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n✝ : ℕ
ha : 1 < a
n : ℕ
a✝ : m.succ.le n
ih : a ^ m < a ^ n
⊢ a ^ m < a ^ n.succ
tactic: induction' hmn with n _ ih
state_before: case refl
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
ha : 1 < a
⊢ a ^ m < a ^ m.succ

case step
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n✝ : ℕ
ha : 1 < a
n : ℕ
a✝ : m.succ.le n
ih : a ^ m < a ^ n
⊢ a ^ m < a ^ n.succ
state_after: no goals
tactic: exacts [pow_lt_pow_succ ha, lt_trans ih (pow_lt_pow_succ ha)]
Theorem: AntilipschitzWith.le_mul_norm
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
K : ℝ≥0
h : AntilipschitzWith K f
hf : f 1 = 1
x : E
⊢ ‖x‖ ≤ ↑K * ‖f x‖
state_after: no goals
tactic: simpa only [dist_one_right, hf] using h.le_mul_dist x 1
Theorem: Sym2.fromRel_bot
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
⊢ fromRel ⋯ = ∅
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
⊢ ∀ (e : Sym2 α), e ∉ fromRel ⋯
tactic: apply Set.eq_empty_of_forall_not_mem fun e => _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
⊢ ∀ (e : Sym2 α), e ∉ fromRel ⋯
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
⊢ ∀ (x y : α), s(x, y) ∉ fromRel ⋯
tactic: apply Sym2.ind
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
r : α → α → Prop
⊢ ∀ (x y : α), s(x, y) ∉ fromRel ⋯
state_after: no goals
tactic: simp [-Set.bot_eq_empty, Prop.bot_eq_false]
Theorem: antivaryOn_iff_mul_rearrangement
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ AntivaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → f i * g i + f j * g j ≤ f i * g j + f j * g i
state_after: no goals
tactic: simp only [smul_eq_mul, antivaryOn_iff_smul_rearrangement]
Theorem: MeasureTheory.IsProjectiveLimit.measure_cylinder
File: Mathlib/MeasureTheory/Constructions/Projective.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
h : IsProjectiveLimit μ P
I : Finset ι
s : Set ((i : { x // x ∈ I }) → α ↑i)
hs : MeasurableSet s
⊢ μ (cylinder I s) = (P I) s
state_after: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
h : IsProjectiveLimit μ P
I : Finset ι
s : Set ((i : { x // x ∈ I }) → α ↑i)
hs : MeasurableSet s
⊢ Measurable fun f i => f ↑i
tactic: rw [cylinder, ← Measure.map_apply _ hs, h I]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
P : (J : Finset ι) → Measure ((j : { x // x ∈ J }) → α ↑j)
μ ν : Measure ((i : ι) → α i)
h : IsProjectiveLimit μ P
I : Finset ι
s : Set ((i : { x // x ∈ I }) → α ↑i)
hs : MeasurableSet s
⊢ Measurable fun f i => f ↑i
state_after: no goals
tactic: exact measurable_pi_lambda _ (fun _ ↦ measurable_pi_apply _)
Theorem: Filter.extraction_of_frequently_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∃ᶠ (n : ℕ) in atTop, P n
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∀ (a : ℕ), ∃ b > a, P b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
tactic: rw [frequently_atTop'] at h
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∀ (a : ℕ), ∃ b > a, P b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
state_after: no goals
tactic: exact extraction_of_frequently_atTop' h