ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PartENat.coe_succ_le_iff
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: n : ℕ
e : PartENat
⊢ ↑n.succ ≤ e ↔ ↑n < e
state_after: no goals
tactic: rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, add_one_le_iff_lt (natCast_ne_top n)]
Theorem: range_toPullbackDiag
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: X : Type u_1
Y : Sort u_2
Z : ?m.78767
f : X → Y
⊢ range (toPullbackDiag f) = pullbackDiagonal f
state_after: no goals
tactic: rw [← image_univ, image_toPullbackDiag, univ_prod_univ, preimage_univ, inter_univ]
Theorem: Polynomial.Monic.mul_right_eq_zero_iff
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
⊢ p * q = 0 ↔ q = 0
state_after: no goals
tactic: by_cases hq : q = 0 <;> simp [h.mul_right_ne_zero, hq]
Theorem: Polynomial.multiplicity_le_one_of_separable
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hq : ¬IsUnit q
hsep : p.Separable
⊢ multiplicity q p ≤ 1
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ IsUnit q
tactic: contrapose! hq
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ IsUnit q
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ q * q ∣ p
tactic: apply isUnit_of_self_mul_dvd_separable hsep
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ q * q ∣ p
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ q ^ 2 ∣ p
tactic: rw [← sq]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ q ^ 2 ∣ p
state_after: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ ↑2 ≤ multiplicity q p
tactic: apply multiplicity.pow_dvd_of_le_multiplicity
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
⊢ ↑2 ≤ multiplicity q p
state_after: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
h : { Dom := Part.Dom 1 ∧ Part.Dom 1, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p
tactic: have h : ⟨Part.Dom 1 ∧ Part.Dom 1, fun _ ↦ 2⟩ ≤ multiplicity q p := PartENat.add_one_le_of_lt hq
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
h : { Dom := Part.Dom 1 ∧ Part.Dom 1, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p
state_after: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
h : { Dom := Part.Dom 1, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p
tactic: rw [and_self] at h
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : p.Separable
hq : 1 < multiplicity q p
h : { Dom := Part.Dom 1, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p
state_after: no goals
tactic: exact h
Theorem: SimpleGraph.isAcyclic_of_path_unique
File: Mathlib/Combinatorics/SimpleGraph/Acyclic.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
h : ∀ (v w : V) (p q : G.Path v w), p = q
⊢ G.IsAcyclic
state_after: V : Type u
G : SimpleGraph V
h : ∀ (v w : V) (p q : G.Path v w), p = q
v : V
c : G.Walk v v
hc : c.IsCycle
⊢ False
tactic: intro v c hc
state_before: V : Type u
G : SimpleGraph V
h : ∀ (v w : V) (p q : G.Path v w), p = q
v : V
c : G.Walk v v
hc : c.IsCycle
⊢ False
state_after: V : Type u
G : SimpleGraph V
h : ∀ (v w : V) (p q : G.Path v w), p = q
v : V
c : G.Walk v v
hc : c.IsTrail ∧ ¬c = nil ∧ c.support.tail.Nodup
⊢ False
tactic: simp only [Walk.isCycle_def, Ne] at hc
state_before: V : Type u
G : SimpleGraph V
h : ∀ (v w : V) (p q : G.Path v w), p = q
v : V
c : G.Walk v v
hc : c.IsTrail ∧ ¬c = nil ∧ c.support.tail.Nodup
⊢ False
state_after: no goals
tactic: cases c with
  | nil => cases hc.2.1 rfl
  | cons ha c' =>
    simp only [Walk.cons_isTrail_iff, Walk.support_cons, List.tail_cons, true_and_iff] at hc
    specialize h _ _ ⟨c', by simp only [Walk.isPath_def, hc.2]⟩ (Path.singleton ha.symm)
    rw [Path.singleton, Subtype.mk.injEq] at h
    simp [h] at hc
Theorem: Filter.frequently_curry_iff
File: Mathlib/Order/Filter/Curry.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
l : Filter α
m : Filter β
p : α × β → Prop
⊢ (∃ᶠ (x : α × β) in l.curry m, p x) ↔ ∃ᶠ (x : α) in l, ∃ᶠ (y : β) in m, p (x, y)
state_after: no goals
tactic: simp_rw [Filter.Frequently, not_iff_not, not_not, eventually_curry_iff]
Theorem: LieSubalgebra.mem_engel_iff
File: Mathlib/Algebra/Lie/EngelSubalgebra.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
⊢ (∃ k, (((ad R L) x - 0 • 1) ^ k) y = 0) ↔ ∃ n, ((ad R L) x ^ n) y = 0
state_after: no goals
tactic: simp only [zero_smul, sub_zero]
Theorem: Stream'.WSeq.destruct_think
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ s.think.destruct.destruct = Sum.inr s.destruct
state_after: no goals
tactic: simp [destruct, think, Computation.rmap]
Theorem: Set.nonempty_of_nonempty_iUnion_eq_univ
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : ι → Set α
inst✝ : Nonempty α
h_Union : ⋃ i, s i = univ
⊢ (⋃ i, s i).Nonempty
state_after: no goals
tactic: simpa only [h_Union] using univ_nonempty
Theorem: CategoryTheory.PreGaloisCategory.card_fiber_coprod_eq_sum
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
tactic: let e : F.obj (X ⨿ Y) ≃ F.obj X ⊕ F.obj Y := Iso.toEquiv
    <| (PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm.trans
    <| Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card (↑(F.obj X) ⊕ ↑(F.obj Y))
tactic: rw [← Nat.card_sum]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card (↑(F.obj X) ⊕ ↑(F.obj Y))
state_after: no goals
tactic: exact Nat.card_eq_of_bijective e.toFun (Equiv.bijective e)
Theorem: String.map_eq
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: f : Char → Char
s : String
⊢ map f s = { data := List.map f s.data }
state_after: no goals
tactic: simpa using mapAux_of_valid f [] s.1
Theorem: MeasureTheory.Measure.IicSnd_apply
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
r : ℝ
s : Set α
hs : MeasurableSet s
⊢ (ρ.IicSnd r) s = ρ (s ×ˢ Iic r)
state_after: no goals
tactic: rw [IicSnd, fst_apply hs,
    restrict_apply' (MeasurableSet.univ.prod (measurableSet_Iic : MeasurableSet (Iic r))), ←
    prod_univ, prod_inter_prod, inter_univ, univ_inter]
Theorem: CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_right
File: Mathlib/CategoryTheory/LiftingProperties/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
⊢ HasLiftingProperty i p ↔ HasLiftingProperty i p'
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p
⊢ HasLiftingProperty i p'

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p'
⊢ HasLiftingProperty i p
tactic: constructor <;> intro
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p
⊢ HasLiftingProperty i p'

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p'
⊢ HasLiftingProperty i p
state_after: no goals
tactic: exacts [of_arrow_iso_right i e, of_arrow_iso_right i e.symm]
Theorem: DFinsupp.zipWith_neLocus_eq_right
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (M a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f₁ f₂ : Π₀ (a : α), M a
g : Π₀ (a : α), N a
hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g
⊢ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂
state_after: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (M a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f₁ f₂ : Π₀ (a : α), M a
g : Π₀ (a : α), N a
hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g
a : α
⊢ a ∈ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) ↔ a ∈ f₁.neLocus f₂
tactic: ext a
state_before: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (M a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f₁ f₂ : Π₀ (a : α), M a
g : Π₀ (a : α), N a
hF : ∀ (a : α) (g : N a), Function.Injective fun f => F a f g
a : α
⊢ a ∈ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) ↔ a ∈ f₁.neLocus f₂
state_after: no goals
tactic: simpa only [mem_neLocus] using (hF a _).ne_iff
Theorem: IsRelPrime.of_mul_right_left
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
H : IsRelPrime x (y * z)
⊢ IsRelPrime x y
state_after: α : Type u_1
inst✝ : CommMonoid α
x y z : α
H : IsRelPrime (y * z) x
⊢ IsRelPrime y x
tactic: rw [isRelPrime_comm] at H ⊢
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
H : IsRelPrime (y * z) x
⊢ IsRelPrime y x
state_after: no goals
tactic: exact H.of_mul_left_left
Theorem: exists_pow_ne_one_of_isCyclic
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
G_cyclic : IsCyclic G
k : ℕ
k_pos : k ≠ 0
k_lt_card_G : k < Fintype.card G
⊢ ∃ a, a ^ k ≠ 1
state_after: case mk.intro
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
k_lt_card_G : k < Fintype.card G
a : G
ha : ∀ (x : G), x ∈ zpowers a
⊢ ∃ a, a ^ k ≠ 1
tactic: rcases G_cyclic with ⟨a, ha⟩
state_before: case mk.intro
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
k_lt_card_G : k < Fintype.card G
a : G
ha : ∀ (x : G), x ∈ zpowers a
⊢ ∃ a, a ^ k ≠ 1
state_after: case h
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
k_lt_card_G : k < Fintype.card G
a : G
ha : ∀ (x : G), x ∈ zpowers a
⊢ a ^ k ≠ 1
tactic: use a
state_before: case h
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
k_lt_card_G : k < Fintype.card G
a : G
ha : ∀ (x : G), x ∈ zpowers a
⊢ a ^ k ≠ 1
state_after: case h
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ Fintype.card G ≤ k
tactic: contrapose! k_lt_card_G
state_before: case h
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ Fintype.card G ≤ k
state_after: case h.e'_3
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ Fintype.card G = orderOf a
tactic: convert orderOf_le_of_pow_eq_one k_pos.bot_lt k_lt_card_G
state_before: case h.e'_3
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ Fintype.card G = orderOf a
state_after: case h.e'_3
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ ⊤ ≤ zpowers a
tactic: rw [← Nat.card_eq_fintype_card, ← Nat.card_zpowers, eq_comm, card_eq_iff_eq_top, eq_top_iff]
state_before: case h.e'_3
α : Type u
a✝ : α
inst✝² : Group α
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
k : ℕ
k_pos : k ≠ 0
a : G
ha : ∀ (x : G), x ∈ zpowers a
k_lt_card_G : a ^ k = 1
⊢ ⊤ ≤ zpowers a
state_after: no goals
tactic: exact fun x _ ↦ ha x
Theorem: TensorProduct.map_add_right
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] P
g₁ g₂ : N →ₗ[R] Q
⊢ map f (g₁ + g₂) = map f g₁ + map f g₂
state_after: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] P
g₁ g₂ : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (g₁ + g₂))) x✝¹) x✝ = (((mk R M N).compr₂ (map f g₁ + map f g₂)) x✝¹) x✝
tactic: ext
state_before: case H.h.h
R : Type u_1
inst✝²⁰ : CommSemiring R
R' : Type u_2
inst✝¹⁹ : Monoid R'
R'' : Type u_3
inst✝¹⁸ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid N
inst✝¹⁵ : AddCommMonoid P
inst✝¹⁴ : AddCommMonoid Q
inst✝¹³ : AddCommMonoid S
inst✝¹² : AddCommMonoid T
inst✝¹¹ : Module R M
inst✝¹⁰ : Module R N
inst✝⁹ : Module R P
inst✝⁸ : Module R Q
inst✝⁷ : Module R S
inst✝⁶ : Module R T
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type u_10
Q' : Type u_11
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] P
g₁ g₂ : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((mk R M N).compr₂ (map f (g₁ + g₂))) x✝¹) x✝ = (((mk R M N).compr₂ (map f g₁ + map f g₂)) x✝¹) x✝
state_after: no goals
tactic: simp only [tmul_add, compr₂_apply, mk_apply, map_tmul, add_apply]
Theorem: HurwitzZeta.hasSum_int_completedHurwitzZetaEven
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
hF :
  ∀ (t : ℝ),
    0 < t →
      HasSum (fun n => if ↑n + a = 0 then 0 else 1 / 2 * ↑(rexp (-π * (↑n + a) ^ 2 * t)))
        ((↑(evenKernel (↑a) t) - ↑(if ↑a = 0 then 1 else 0)) / 2)
⊢ HasSum (fun n => s.Gammaℝ / ↑|↑n + a| ^ s / 2)
    (mellin (fun t => (↑(evenKernel (↑a) t) - ↑(if ↑a = 0 then 1 else 0)) / 2) (s / 2))
state_after: case refine_1
a : ℝ
s : ℂ
hs : 1 < s.re
hF :
  ∀ (t : ℝ),
    0 < t →
      HasSum (fun n => if ↑n + a = 0 then 0 else 1 / 2 * ↑(rexp (-π * (↑n + a) ^ 2 * t)))
        ((↑(evenKernel (↑a) t) - ↑(if ↑a = 0 then 1 else 0)) / 2)
⊢ Summable fun i => ‖1 / 2‖ / |↑i + a| ^ s.re

case refine_2
a : ℝ
s : ℂ
hs : 1 < s.re
hF :
  ∀ (t : ℝ),
    0 < t →
      HasSum (fun n => if ↑n + a = 0 then 0 else 1 / 2 * ↑(rexp (-π * (↑n + a) ^ 2 * t)))
        ((↑(evenKernel (↑a) t) - ↑(if ↑a = 0 then 1 else 0)) / 2)
n : ℤ
⊢ s.Gammaℝ / ↑|↑n + a| ^ s / 2 = s.Gammaℝ * (1 / 2) / ↑|↑n + a| ^ s
tactic: refine (hasSum_mellin_pi_mul_sq (zero_lt_one.trans hs) hF ?_).congr_fun fun n ↦ ?_
Theorem: WellFounded.monotone_chain_condition'
File: Mathlib/Order/OrderIsoNat.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
⊢ (WellFounded fun x x_1 => x > x_1) ↔ ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
state_after: case refine_1
α : Type u_1
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : ℕ →o α
⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m

case refine_2
α : Type u_1
inst✝ : Preorder α
h : ∀ (a : ℕ →o α), ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m
⊢ WellFounded fun x x_1 => x > x_1
tactic: refine ⟨fun h a => ?_, fun h => ?_⟩
Theorem: HomologicalComplex₂.totalAux.d₁_eq'
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ i₁' : I₁
h : c₁.Rel i₁ i₁'
i₂ : I₂
i₁₂ : I₁₂
⊢ K.d₁ c₁₂ i₁ i₂ i₁₂ =
    c₁.ε₁ c₂ c₁₂ (i₁, i₂) • (K.d i₁ i₁').f i₂ ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (i₁', i₂) i₁₂
state_after: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : c₁.Rel i₁ (c₁.next i₁)
⊢ K.d₁ c₁₂ i₁ i₂ i₁₂ =
    c₁.ε₁ c₂ c₁₂ (i₁, i₂) •
      (K.d i₁ (c₁.next i₁)).f i₂ ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (c₁.next i₁, i₂) i₁₂
tactic: obtain rfl := c₁.next_eq' h
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : c₁.Rel i₁ (c₁.next i₁)
⊢ K.d₁ c₁₂ i₁ i₂ i₁₂ =
    c₁.ε₁ c₂ c₁₂ (i₁, i₂) •
      (K.d i₁ (c₁.next i₁)).f i₂ ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (c₁.next i₁, i₂) i₁₂
state_after: no goals
tactic: rfl
Theorem: UniformInducing.uniformContinuousOn_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
S : Set α
hg : UniformInducing g
⊢ UniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
S : Set α
hg : UniformInducing g
⊢ map (fun x => (f x.1, f x.2)) (𝓤 α ⊓ 𝓟 (S ×ˢ S)) ≤ 𝓤 β ↔
    map (fun x => ((g ∘ f) x.1, (g ∘ f) x.2)) (𝓤 α ⊓ 𝓟 (S ×ˢ S)) ≤ 𝓤 γ
tactic: dsimp only [UniformContinuousOn, Tendsto]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
S : Set α
hg : UniformInducing g
⊢ map (fun x => (f x.1, f x.2)) (𝓤 α ⊓ 𝓟 (S ×ˢ S)) ≤ 𝓤 β ↔
    map (fun x => ((g ∘ f) x.1, (g ∘ f) x.2)) (𝓤 α ⊓ 𝓟 (S ×ˢ S)) ≤ 𝓤 γ
state_after: no goals
tactic: rw [← hg.comap_uniformity, ← map_le_iff_le_comap, Filter.map_map, comp_def, comp_def]
Theorem: csSup_sub
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddAbove s
ht₀ : t.Nonempty
ht₁ : BddBelow t
⊢ sSup (s / t) = sSup s / sInf t
state_after: no goals
tactic: rw [div_eq_mul_inv, csSup_mul hs₀ hs₁ ht₀.inv ht₁.inv, csSup_inv ht₀ ht₁, div_eq_mul_inv]
Theorem: NonUnitalSubring.mem_bot
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

Proof steps:
state_before: F : Type w
R : Type u
S : Type v
T : Type u_1
inst✝⁴ : NonUnitalNonAssocRing R
inst✝³ : NonUnitalNonAssocRing S
inst✝² : NonUnitalNonAssocRing T
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
g : S →ₙ+* T
f : R →ₙ+* S
x : R
⊢ x ∈ ↑⊥ ↔ x = 0
state_after: no goals
tactic: rw [coe_bot, Set.mem_singleton_iff]