ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ F.Initial
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ F.op.Final
tactic: suffices Final F.op from initial_of_final_op _
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ F.op.Final
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
tactic: refine Functor.final_of_exists_of_isFiltered_of_fullyFaithful F.op (fun d => ?_)
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ unop d
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
tactic: obtain ⟨c, ⟨f⟩⟩ := h d.unop
state_before: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ unop d
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: no goals
tactic: exact ⟨op c, ⟨f.op⟩⟩
Theorem: unitInterval.two_mul_sub_one_mem_iff
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: t : ℝ
⊢ 2 * t - 1 ∈ I ↔ t ∈ Icc (1 / 2) 1
state_after: no goals
tactic: constructor <;> rintro ⟨h₁, h₂⟩ <;> constructor <;> linarith
Theorem: Prod.map_leftInverse
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
⊢ f₁ (f₂ b) = b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
inhabited_h : Inhabited δ
⊢ f₁ (f₂ b) = b
tactic: inhabit δ
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
inhabited_h : Inhabited δ
⊢ f₁ (f₂ b) = b
state_after: no goals
tactic: exact congr_arg Prod.fst (h (b, default))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
d : δ
⊢ g₁ (g₂ d) = d
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
d : δ
inhabited_h : Inhabited β
⊢ g₁ (g₂ d) = d
tactic: inhabit β
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
d : δ
inhabited_h : Inhabited β
⊢ g₁ (g₂ d) = d
state_after: no goals
tactic: exact congr_arg Prod.snd (h (default, d))
Theorem: CategoryTheory.Limits.Types.Image.lift_fac
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
⊢ lift F' ≫ F'.m = ι f
state_after: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ (lift F' ≫ F'.m) x = ι f x
tactic: funext x
state_before: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ (lift F' ≫ F'.m) x = ι f x
state_after: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = ι f x
tactic: change (F'.e ≫ F'.m) _ = _
state_before: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ (F'.e ≫ F'.m) ↑(Classical.indefiniteDescription (fun x_1 => f x_1 = ↑x) ⋯) = ι f x
state_after: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ ↑x = ι f x
tactic: rw [F'.fac, (Classical.indefiniteDescription _ x.2).2]
state_before: case h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
α β : Type u
f : α ⟶ β
F' : MonoFactorisation f
x : Image f
⊢ ↑x = ι f x
state_after: no goals
tactic: rfl
Theorem: multiplicity.finite_int_iff
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a b : ℤ
⊢ Finite a b ↔ a.natAbs ≠ 1 ∧ b ≠ 0
state_after: no goals
tactic: rw [finite_int_iff_natAbs_finite, finite_nat_iff, pos_iff_ne_zero, Int.natAbs_ne_zero]
Theorem: Set.apply_piecewise
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
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ' : α → Sort u_7
h : (i : α) → δ i → δ' i
x : α
⊢ h x (s.piecewise f g x) = s.piecewise (fun x => h x (f x)) (fun x => h x (g x)) x
state_after: no goals
tactic: by_cases hx : x ∈ s <;> simp [hx]
Theorem: Module.sum_smul_eq_zero_of_isTrivialRelation
File: Mathlib/RingTheory/Flat/EquationalCriterion.lean

Proof steps:
state_before: R M : Type u
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u
inst✝ : Fintype ι
f : ι → R
x : ι → M
h : IsTrivialRelation f x
⊢ ∑ i : ι, f i • x i = 0
state_after: no goals
tactic: simpa using
    congr_arg (TensorProduct.lid R M) <|
      sum_tmul_eq_zero_of_vanishesTrivially R (isTrivialRelation_iff_vanishesTrivially.mp h)
Theorem: QuadraticMap.map_neg
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticMap R M N
x : M
⊢ Q (-x) = Q x
state_after: no goals
tactic: rw [← @neg_one_smul R _ _ _ _ x, map_smul, neg_one_mul, neg_neg, one_smul]
Theorem: finSuccAboveOrderIso_symm_apply_ne_last
File: Mathlib/Order/Fin/Tuple.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
n✝ : ℕ
f : Fin (n✝ + 1) → α
a : α
n : ℕ
p : Fin (n + 1)
h : p ≠ last n
x : { x // x ≠ p }
⊢ (finSuccAboveEquiv p).symm x = (p.castLT ⋯).predAbove ↑x
state_after: α : Type u_1
inst✝ : Preorder α
n✝ : ℕ
f : Fin (n✝ + 1) → α
a : α
n : ℕ
p : Fin (n + 1)
h : p ≠ last n
x : { x // x ≠ p }
⊢ some ((finSuccAboveEquiv p).symm x) = some ((p.castLT ⋯).predAbove ↑x)
tactic: rw [← Option.some_inj]
state_before: α : Type u_1
inst✝ : Preorder α
n✝ : ℕ
f : Fin (n✝ + 1) → α
a : α
n : ℕ
p : Fin (n + 1)
h : p ≠ last n
x : { x // x ≠ p }
⊢ some ((finSuccAboveEquiv p).symm x) = some ((p.castLT ⋯).predAbove ↑x)
state_after: no goals
tactic: simpa [finSuccAboveEquiv, OrderIso.symm] using finSuccEquiv'_ne_last_apply h x.property
Theorem: Set.finite_subset_iUnion
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i
tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i
tactic: choose f hf using show ∀ x : s, ∃ i, x.1 ∈ t i by simpa [subset_def] using h
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ x ∈ ⋃ i ∈ range f, t i
tactic: refine ⟨range f, finite_range f, fun x hx => ?_⟩
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ x ∈ ⋃ i ∈ range f, t i
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ ∃ i, x ∈ t (f i)
tactic: rw [biUnion_range, mem_iUnion]
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : s.Finite
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ i, t i
this : Finite ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ ∃ i, x ∈ t (f i)
state_after: no goals
tactic: exact ⟨⟨x, hx⟩, hf _⟩
Theorem: Sum.comp_traverse
File: Mathlib/Control/Traversable/Instances.lean

Proof steps:
state_before: σ : Type u
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
x : σ ⊕ α
⊢ Sum.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Comp.mk (Sum.traverse f <$> Sum.traverse g x)
state_after: no goals
tactic: cases x <;> simp! [Sum.traverse, map_id, functor_norm] <;> rfl
Theorem: Sylow.normalizer_normalizer
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : (↑(P.subtype ⋯)).normalizer.Normal → (↑(P.subtype ⋯)).Normal
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
tactic: have := normal_of_normalizer_normal (P.subtype (le_normalizer.trans le_normalizer))
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : (↑(P.subtype ⋯)).normalizer.Normal → (↑(P.subtype ⋯)).Normal
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
tactic: simp_rw [← normalizer_eq_top, Sylow.coe_subtype, ← subgroupOf_normalizer_eq le_normalizer, ←
    subgroupOf_normalizer_eq le_rfl, subgroupOf_self] at this
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ (↑P).normalizer.normalizer = (↑P).normalizer
state_after: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ Subgroup.map (↑P).normalizer.normalizer.subtype ((↑P).normalizer.subgroupOf (↑P).normalizer.normalizer) =
    (↑P).normalizer
tactic: rw [← subtype_range (P : Subgroup G).normalizer.normalizer, MonoidHom.range_eq_map,
    ← this trivial]
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this : True → (↑P).normalizer.subgroupOf (↑P).normalizer.normalizer = ⊤
⊢ Subgroup.map (↑P).normalizer.normalizer.subtype ((↑P).normalizer.subgroupOf (↑P).normalizer.normalizer) =
    (↑P).normalizer
state_after: no goals
tactic: exact map_comap_eq_self (le_normalizer.trans (ge_of_eq (subtype_range _)))
Theorem: CategoryTheory.ProjectiveResolution.self_complex
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
inst✝ : Projective Z
n : ℕ
⊢ Projective (((single₀ C).obj Z).X n)
state_after: case zero
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
inst✝ : Projective Z
⊢ Projective (((single₀ C).obj Z).X 0)

case succ
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
inst✝ : Projective Z
n✝ : ℕ
⊢ Projective (((single₀ C).obj Z).X (n✝ + 1))
tactic: cases n
Theorem: EllipticCurve.variableChange_comp
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
E✝ : EllipticCurve R
C✝ C C' : WeierstrassCurve.VariableChange R
E : EllipticCurve R
⊢ E.variableChange (C.comp C') = (E.variableChange C').variableChange C
state_after: R : Type u
inst✝ : CommRing R
E✝ : EllipticCurve R
C✝ C C' : WeierstrassCurve.VariableChange R
E : EllipticCurve R
⊢ { toWeierstrassCurve := (E.variableChange C').variableChange C, Δ' := (C.comp C').u⁻¹ ^ 12 * E.Δ', coe_Δ' := ⋯ } =
    { toWeierstrassCurve := (E.variableChange C').variableChange C, Δ' := C.u⁻¹ ^ 12 * (C'.u⁻¹ ^ 12 * E.Δ'),
      coe_Δ' := ⋯ }
tactic: simp only [variableChange, WeierstrassCurve.variableChange_comp]
state_before: R : Type u
inst✝ : CommRing R
E✝ : EllipticCurve R
C✝ C C' : WeierstrassCurve.VariableChange R
E : EllipticCurve R
⊢ { toWeierstrassCurve := (E.variableChange C').variableChange C, Δ' := (C.comp C').u⁻¹ ^ 12 * E.Δ', coe_Δ' := ⋯ } =
    { toWeierstrassCurve := (E.variableChange C').variableChange C, Δ' := C.u⁻¹ ^ 12 * (C'.u⁻¹ ^ 12 * E.Δ'),
      coe_Δ' := ⋯ }
state_after: no goals
tactic: simp only [WeierstrassCurve.VariableChange.comp, mul_inv, mul_pow, ← mul_assoc]
Theorem: Complex.map_exp_comap_re_atTop
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: ⊢ map cexp (comap re atTop) = cobounded ℂ
state_after: ⊢ {0}ᶜ ∈ cobounded ℂ
tactic: rw [← comap_exp_cobounded, map_comap, range_exp, inf_eq_left, le_principal_iff]
state_before: ⊢ {0}ᶜ ∈ cobounded ℂ
state_after: no goals
tactic: exact eventually_ne_cobounded _
Theorem: SetTheory.PGame.Subsequent.moveLeft_mk_left
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
xR : xr → PGame
i : xl
xL : xl → PGame
j : (xL i).LeftMoves
⊢ ((xL i).moveLeft j).Subsequent (mk xl xr xL xR)
state_after: no goals
tactic: pgame_wf_tac
Theorem: sInf_within_of_ordConnected
File: Mathlib/Order/CompleteLatticeIntervals.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
ht : t.Nonempty
h_bdd : BddBelow t
⊢ sInf (Subtype.val '' t) ∈ s
state_after: case intro
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
h_bdd : BddBelow t
c : ↑s
hct : c ∈ t
⊢ sInf (Subtype.val '' t) ∈ s
tactic: obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
state_before: case intro
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
h_bdd : BddBelow t
c : ↑s
hct : c ∈ t
⊢ sInf (Subtype.val '' t) ∈ s
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ sInf (Subtype.val '' t) ∈ s
tactic: obtain ⟨B, hB⟩ : ∃ B, B ∈ lowerBounds t := h_bdd
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ sInf (Subtype.val '' t) ∈ s
state_after: case intro.intro.refine_1
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ ↑B ≤ sInf (Subtype.val '' t)

case intro.intro.refine_2
ι : Sort u_1
α : Type u_2
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : s.OrdConnected
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ lowerBounds t
⊢ sInf (Subtype.val '' t) ≤ ↑c
tactic: refine hs.out B.2 c.2 ⟨?_, ?_⟩
Theorem: Filter.comap_le_iff_le_kernMap
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m g ≤ f ↔ g ≤ kernMap m f
state_after: no goals
tactic: simp [Filter.le_def, mem_comap'', mem_kernMap, -mem_comap]
Theorem: Sum.liftRel_swap_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: β✝¹ : Type u_1
β✝ : Type u_2
s : β✝¹ → β✝ → Prop
α✝¹ : Type u_3
α✝ : Type u_4
r : α✝¹ → α✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
h : LiftRel s r x.swap y.swap
⊢ LiftRel r s x y
state_after: β✝¹ : Type u_1
β✝ : Type u_2
s : β✝¹ → β✝ → Prop
α✝¹ : Type u_3
α✝ : Type u_4
r : α✝¹ → α✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
h : LiftRel s r x.swap y.swap
⊢ LiftRel r s x.swap.swap y.swap.swap
tactic: rw [← swap_swap x, ← swap_swap y]
state_before: β✝¹ : Type u_1
β✝ : Type u_2
s : β✝¹ → β✝ → Prop
α✝¹ : Type u_3
α✝ : Type u_4
r : α✝¹ → α✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
h : LiftRel s r x.swap y.swap
⊢ LiftRel r s x.swap.swap y.swap.swap
state_after: no goals
tactic: exact h.swap
Theorem: mem_nhds_uniformity_iff_right
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ {p | p.1 = x → p.2 ∈ s} ∈ 𝓤 α
state_after: no goals
tactic: simp only [nhds_eq_comap_uniformity, mem_comap_prod_mk]
Theorem: BumpCovering.smooth_toPartitionOfUnity
File: Mathlib/Geometry/Manifold/PartitionOfUnity.lean

Proof steps:
state_before: ι : Type uι
E✝ : Type uE
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : NormedSpace ℝ E✝
inst✝¹¹ : FiniteDimensional ℝ E✝
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
H✝ : Type uH
inst✝⁸ : TopologicalSpace H✝
I✝ : ModelWithCorners ℝ E✝ H✝
M✝ : Type uM
inst✝⁷ : TopologicalSpace M✝
inst✝⁶ : ChartedSpace H✝ M✝
inst✝⁵ : SmoothManifoldWithCorners I✝ M✝
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
H : Type uH
inst✝² : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
s : Set M
f : BumpCovering ι M s
hf : ∀ (i : ι), Smooth I 𝓘(ℝ, ℝ) ⇑(f i)
i : ι
⊢ LocallyFinite fun i => mulSupport ((fun x => 1) - ⇑(f i))
state_after: ι : Type uι
E✝ : Type uE
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : NormedSpace ℝ E✝
inst✝¹¹ : FiniteDimensional ℝ E✝
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
H✝ : Type uH
inst✝⁸ : TopologicalSpace H✝
I✝ : ModelWithCorners ℝ E✝ H✝
M✝ : Type uM
inst✝⁷ : TopologicalSpace M✝
inst✝⁶ : ChartedSpace H✝ M✝
inst✝⁵ : SmoothManifoldWithCorners I✝ M✝
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
H : Type uH
inst✝² : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
s : Set M
f : BumpCovering ι M s
hf : ∀ (i : ι), Smooth I 𝓘(ℝ, ℝ) ⇑(f i)
i : ι
⊢ LocallyFinite fun i => support ⇑(f i)
tactic: simp only [Pi.sub_def, mulSupport_one_sub]
state_before: ι : Type uι
E✝ : Type uE
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : NormedSpace ℝ E✝
inst✝¹¹ : FiniteDimensional ℝ E✝
F : Type uF
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
H✝ : Type uH
inst✝⁸ : TopologicalSpace H✝
I✝ : ModelWithCorners ℝ E✝ H✝
M✝ : Type uM
inst✝⁷ : TopologicalSpace M✝
inst✝⁶ : ChartedSpace H✝ M✝
inst✝⁵ : SmoothManifoldWithCorners I✝ M✝
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
H : Type uH
inst✝² : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
s : Set M
f : BumpCovering ι M s
hf : ∀ (i : ι), Smooth I 𝓘(ℝ, ℝ) ⇑(f i)
i : ι
⊢ LocallyFinite fun i => support ⇑(f i)
state_after: no goals
tactic: exact f.locallyFinite
Theorem: Even.zpow_nonneg
File: Mathlib/Algebra/Order/Field/Power.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d : α
n : ℤ
hn : Even n
a : α
⊢ 0 ≤ a ^ n
state_after: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ (k + k)
tactic: obtain ⟨k, rfl⟩ := hn
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ (k + k)
state_after: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ k * a ^ k
tactic: rw [zpow_add' (by simp [em'])]
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a✝ b c d a : α
k : ℤ
⊢ 0 ≤ a ^ k * a ^ k
state_after: no goals
tactic: exact mul_self_nonneg _
Theorem: ofNat_mem
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike S R
s✝ : S
inst✝¹ : AddSubmonoidWithOneClass S R
s : S
n : ℕ
inst✝ : n.AtLeastTwo
⊢ OfNat.ofNat n ∈ s
state_after: S : Type u_1
R : Type u_2
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike S R
s✝ : S
inst✝¹ : AddSubmonoidWithOneClass S R
s : S
n : ℕ
inst✝ : n.AtLeastTwo
⊢ ↑n ∈ s
tactic: rw [← Nat.cast_eq_ofNat]
state_before: S : Type u_1
R : Type u_2
inst✝³ : AddMonoidWithOne R
inst✝² : SetLike S R
s✝ : S
inst✝¹ : AddSubmonoidWithOneClass S R
s : S
n : ℕ
inst✝ : n.AtLeastTwo
⊢ ↑n ∈ s
state_after: no goals
tactic: exact natCast_mem s n
Theorem: Finset.prod_mul_prod_comm
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✝ : α → β
inst✝ : CommMonoid β
f g h i : α → β
⊢ (∏ a ∈ s, f a * g a) * ∏ a ∈ s, h a * i a = (∏ a ∈ s, f a * h a) * ∏ a ∈ s, g a * i a
state_after: no goals
tactic: simp_rw [prod_mul_distrib, mul_mul_mul_comm]