ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: _private.Mathlib.Algebra.Lie.CartanMatrix.0.CartanMatrix.Relations.adE_of_eq_eq_zero
File: Mathlib/Algebra/Lie/CartanMatrix.lean

Proof steps:
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
⊢ adE R A (i, i) = 0
state_after: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adE R A (i, i) = 0
tactic: have h' : (-2 : ℤ).toNat = 0 := rfl
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adE R A (i, i) = 0
state_after: no goals
tactic: simp [adE, h, h']
Theorem: LinearLocallyFiniteOrder.le_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ i ≤ succFn i
state_after: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ ∀ x ∈ Set.Ioi i, i ≤ x
tactic: rw [le_isGLB_iff (succFn_spec i), mem_lowerBounds]
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i : ι
⊢ ∀ x ∈ Set.Ioi i, i ≤ x
state_after: no goals
tactic: exact fun x hx ↦ le_of_lt hx
Theorem: Submodule.prod_le_iff
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q✝ : Submodule R M₂
p₁ : Submodule R M
p₂ : Submodule R M₂
q : Submodule R (M × M₂)
⊢ p₁.prod p₂ ≤ q ↔ map (inl R M M₂) p₁ ≤ q ∧ map (inr R M M₂) p₂ ≤ q
state_after: case mp
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q✝ : Submodule R M₂
p₁ : Submodule R M
p₂ : Submodule R M₂
q : Submodule R (M × M₂)
⊢ p₁.prod p₂ ≤ q → map (inl R M M₂) p₁ ≤ q ∧ map (inr R M M₂) p₂ ≤ q

case mpr
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q✝ : Submodule R M₂
p₁ : Submodule R M
p₂ : Submodule R M₂
q : Submodule R (M × M₂)
⊢ map (inl R M M₂) p₁ ≤ q ∧ map (inr R M M₂) p₂ ≤ q → p₁.prod p₂ ≤ q
tactic: constructor
Theorem: CategoryTheory.Paths.lift_toPath
File: Mathlib/CategoryTheory/PathCategory.lean

Proof steps:
state_before: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category.{u_2, u_1} C
φ : V ⥤q C
X Y : V
f : X ⟶ Y
⊢ (lift φ).map f.toPath = φ.map f
state_after: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category.{u_2, u_1} C
φ : V ⥤q C
X Y : V
f : X ⟶ Y
⊢ 𝟙 (φ.obj X) ≫ φ.map f = φ.map f
tactic: dsimp [Quiver.Hom.toPath, lift]
state_before: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category.{u_2, u_1} C
φ : V ⥤q C
X Y : V
f : X ⟶ Y
⊢ 𝟙 (φ.obj X) ≫ φ.map f = φ.map f
state_after: no goals
tactic: simp
Theorem: ContinuousLinearMap.norm_id_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : FunLike 𝓕 E F
x : E
⊢ ‖(id 𝕜 E) x‖ ≤ 1 * ‖x‖
state_after: no goals
tactic: simp
Theorem: MultilinearMap.mkContinuousLinear_norm_le'
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : G →ₗ[𝕜] MultilinearMap 𝕜 E G'
C : ℝ
H : ∀ (x : G) (m : (i : ι) → E i), ‖(f x) m‖ ≤ C * ‖x‖ * ∏ i : ι, ‖m i‖
⊢ ‖mkContinuousLinear f C H‖ ≤ max C 0
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : G →ₗ[𝕜] MultilinearMap 𝕜 E G'
C : ℝ
H : ∀ (x : G) (m : (i : ι) → E i), ‖(f x) m‖ ≤ C * ‖x‖ * ∏ i : ι, ‖m i‖
⊢ ‖{ toFun := fun x => (f x).mkContinuous (C * ‖x‖) ⋯, map_add' := ⋯, map_smul' := ⋯ }.mkContinuous (max C 0) ⋯‖ ≤
    max C 0
tactic: dsimp only [mkContinuousLinear]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : G →ₗ[𝕜] MultilinearMap 𝕜 E G'
C : ℝ
H : ∀ (x : G) (m : (i : ι) → E i), ‖(f x) m‖ ≤ C * ‖x‖ * ∏ i : ι, ‖m i‖
⊢ ‖{ toFun := fun x => (f x).mkContinuous (C * ‖x‖) ⋯, map_add' := ⋯, map_smul' := ⋯ }.mkContinuous (max C 0) ⋯‖ ≤
    max C 0
state_after: no goals
tactic: exact LinearMap.mkContinuous_norm_le _ (le_max_right _ _) _
Theorem: IsPrimitiveRoot.coe_units_iff
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 : ℕ
ζ✝ : M
f : F
h : IsPrimitiveRoot ζ✝ k
ζ : Mˣ
⊢ IsPrimitiveRoot (↑ζ) k ↔ IsPrimitiveRoot ζ k
state_after: no goals
tactic: simp only [iff_def, Units.ext_iff, Units.val_pow_eq_pow_val, Units.val_one]
Theorem: Nat.div2_succ
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ n.succ.div2 = bif n.bodd then n.div2.succ else n.div2
state_after: m n✝ n : ℕ
⊢ (match n.boddDiv2 with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).2 =
    bif n.boddDiv2.1 then n.boddDiv2.2.succ else n.boddDiv2.2
tactic: simp only [bodd, boddDiv2, div2]
state_before: m n✝ n : ℕ
⊢ (match n.boddDiv2 with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).2 =
    bif n.boddDiv2.1 then n.boddDiv2.2.succ else n.boddDiv2.2
state_after: no goals
tactic: rcases boddDiv2 n with ⟨_|_, _⟩ <;> simp
Theorem: AlgebraicGeometry.RingedSpace.basicOpen_le
File: Mathlib/Geometry/RingedSpace/Basic.lean

Proof steps:
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
⊢ X.basicOpen f ≤ U
state_after: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
x : ↥U
left✝ : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
⊢ ↑x ∈ ↑U
tactic: rintro _ ⟨x, _, rfl⟩
state_before: case intro.intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
x : ↥U
left✝ : x ∈ {x | IsUnit ((X.presheaf.germ x) f)}
⊢ ↑x ∈ ↑U
state_after: no goals
tactic: exact x.2
Theorem: HomologicalComplex.d_comp_eqToHom
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j j' : ι
rij : c.Rel i j
rij' : c.Rel i j'
⊢ C.d i j' ≫ eqToHom ⋯ = C.d i j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : c.Rel i j
⊢ C.d i j ≫ eqToHom ⋯ = C.d i j
tactic: obtain rfl := c.next_eq rij rij'
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : c.Rel i j
⊢ C.d i j ≫ eqToHom ⋯ = C.d i j
state_after: no goals
tactic: simp only [eqToHom_refl, comp_id]
Theorem: Set.SurjOn.leftInvOn_of_rightInvOn
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 t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
⊢ f (f' y) = y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
x : α
hx : x ∈ s
heq : f x = y
⊢ f (f' y) = y
tactic: let ⟨x, hx, heq⟩ := hf hy
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : SurjOn f s t
hf' : RightInvOn f f' s
y : β
hy : y ∈ t
x : α
hx : x ∈ s
heq : f x = y
⊢ f (f' y) = y
state_after: no goals
tactic: rw [← heq, hf' hx]
Theorem: singleton_mem_nhdsWithin_of_mem_discrete
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hx : x ∈ s
⊢ {x} ∈ 𝓝[s] x
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hx : x ∈ s
this : {⟨x, hx⟩} ∈ 𝓝 ⟨x, hx⟩
⊢ {x} ∈ 𝓝[s] x
tactic: have : ({⟨x, hx⟩} : Set s) ∈ 𝓝 (⟨x, hx⟩ : s) := by simp [nhds_discrete]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
s : Set X
inst✝ : DiscreteTopology ↑s
x : X
hx : x ∈ s
this : {⟨x, hx⟩} ∈ 𝓝 ⟨x, hx⟩
⊢ {x} ∈ 𝓝[s] x
state_after: no goals
tactic: simpa only [nhdsWithin_eq_map_subtype_coe hx, image_singleton] using
    @image_mem_map _ _ _ ((↑) : s → X) _ this
Theorem: EMetric.inseparable_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ Inseparable x y ↔ edist x y = 0
state_after: no goals
tactic: simp [inseparable_iff_mem_closure, mem_closure_iff, edist_comm, forall_lt_iff_le']
Theorem: IsCyclic.image_range_orderOf
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ zpowers a
⊢ image (fun i => a ^ i) (range (orderOf a)) = univ
state_after: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ ↑(zpowers a)
⊢ image (fun i => a ^ i) (range (orderOf a)) = univ
tactic: simp_rw [← SetLike.mem_coe] at ha
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ ↑(zpowers a)
⊢ image (fun i => a ^ i) (range (orderOf a)) = univ
state_after: no goals
tactic: simp only [_root_.image_range_orderOf, Set.eq_univ_iff_forall.mpr ha, Set.toFinset_univ]
Theorem: topologicalGroup_inf
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
⊢ TopologicalGroup G
state_after: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
b : Bool
⊢ TopologicalGroup G
tactic: refine topologicalGroup_iInf fun b => ?_
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
b : Bool
⊢ TopologicalGroup G
state_after: no goals
tactic: cases b <;> assumption
Theorem: CategoryTheory.Limits.diagramIsoParallelPair_inv_app
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
F : WalkingParallelPair ⥤ C
j : WalkingParallelPair
⊢ F.obj j = (parallelPair (F.map left) (F.map right)).obj j
state_after: no goals
tactic: cases j <;> rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
F : WalkingParallelPair ⥤ C
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso ⋯) Y).hom =
      ((fun j => eqToIso ⋯) X).hom ≫ (parallelPair (F.map left) (F.map right)).map f
state_after: no goals
tactic: rintro _ _ (_|_|_) <;> simp
Theorem: CauSeq.one_not_equiv_zero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : LinearOrderedField α
inst✝² : Ring β
inst✝¹ : IsDomain β
abv : β → α
inst✝ : IsAbsoluteValue abv
h : const abv 1 ≈ const abv 0
this : ∀ ε > 0, ∃ i, ∀ (k : ℕ), i ≤ k → abv (1 - 0) < ε
h2 : 0 < abv 1
i : ℕ
hi : ∀ (k : ℕ), i ≤ k → abv (1 - 0) < abv 1
⊢ abv 1 < abv 1
state_after: no goals
tactic: simpa using hi _ le_rfl
Theorem: Finset.mem_vaddAntidiagonal
File: Mathlib/Data/Finset/SMulAntidiagonal.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
a : P
u : Set G
hu : u.IsPWO
v : Set P
hv : v.IsPWO
x : G × P
⊢ x ∈ SMulAntidiagonal hs ht a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a
state_after: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
a : P
u : Set G
hu : u.IsPWO
v : Set P
hv : v.IsPWO
x : G × P
⊢ x ∈ s.smulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a
tactic: simp only [SMulAntidiagonal, Set.Finite.mem_toFinset]
state_before: G : Type u_1
P : Type u_2
inst✝³ : PartialOrder G
inst✝² : PartialOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsPWO
ht : t.IsPWO
a : P
u : Set G
hu : u.IsPWO
v : Set P
hv : v.IsPWO
x : G × P
⊢ x ∈ s.smulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 • x.2 = a
state_after: no goals
tactic: exact Set.mem_sep_iff
Theorem: MonoidHom.comp_mul
File: Mathlib/Algebra/Group/Hom/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
⊢ g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂
state_after: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
x✝ : M
⊢ (g.comp (f₁ * f₂)) x✝ = (g.comp f₁ * g.comp f₂) x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
x✝ : M
⊢ (g.comp (f₁ * f₂)) x✝ = (g.comp f₁ * g.comp f₂) x✝
state_after: no goals
tactic: simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
Theorem: dist_homothety_center
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist ((homothety p₁ c) p₂) p₁ = ‖c‖ * dist p₁ p₂
state_after: no goals
tactic: rw [dist_comm, dist_center_homothety]
Theorem: Bitraversable.comp_tfst
File: Mathlib/Control/Bitraversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : LawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ α₂ β : Type u
f : α₀ → F α₁
f' : α₁ → G α₂
x : t α₀ β
⊢ Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x
state_after: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : LawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ α₂ β : Type u
f : α₀ → F α₁
f' : α₁ → G α₂
x : t α₀ β
⊢ bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x
tactic: rw [← comp_bitraverse]
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : LawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ α₂ β : Type u
f : α₀ → F α₁
f' : α₁ → G α₂
x : t α₀ β
⊢ bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x
state_after: no goals
tactic: simp only [Function.comp, tfst, map_pure, Pure.pure]
Theorem: Nat.cast_one
File: Mathlib/Data/Nat/Cast/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
⊢ ↑1 = 1
state_after: no goals
tactic: rw [cast_succ, Nat.cast_zero, zero_add]
Theorem: Polynomial.IsWeaklyEisensteinAt.map
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ (Polynomial.map φ f).IsWeaklyEisensteinAt (Ideal.map φ 𝓟)
state_after: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ (Polynomial.map φ f).coeff n✝ ∈ Ideal.map φ 𝓟
tactic: refine (isWeaklyEisensteinAt_iff _ _).2 fun hn => ?_
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ (Polynomial.map φ f).coeff n✝ ∈ Ideal.map φ 𝓟
state_after: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ φ (f.coeff n✝) ∈ Ideal.map φ 𝓟
tactic: rw [coeff_map]
state_before: R : Type u
inst✝¹ : CommSemiring R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
A : Type v
inst✝ : CommRing A
φ : R →+* A
n✝ : ℕ
hn : n✝ < (Polynomial.map φ f).natDegree
⊢ φ (f.coeff n✝) ∈ Ideal.map φ 𝓟
state_after: no goals
tactic: exact mem_map_of_mem _ (hf.mem (lt_of_lt_of_le hn (natDegree_map_le _ _)))
Theorem: Set.image_preimage_eq_of_subset
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
hs : s ⊆ range f
⊢ f '' (f ⁻¹' s) = s
state_after: no goals
tactic: rw [image_preimage_eq_range_inter, inter_eq_self_of_subset_right hs]
Theorem: Metric.exists_mem_closure_infDist_eq_dist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
s t u : Set α
x✝ y : α
Φ : α → β
inst✝ : ProperSpace α
hne : s.Nonempty
x : α
⊢ ∃ y ∈ closure s, infDist x s = dist x y
state_after: no goals
tactic: simpa only [infDist_closure] using isClosed_closure.exists_infDist_eq_dist hne.closure x
Theorem: edist_le_of_edist_le_geometric_two_of_tendsto
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C / 2 ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ edist (f n) a ≤ 2 * C / 2 ^ n
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ edist (f n) a ≤ 2 * C * 2⁻¹ ^ n
tactic: simp only [div_eq_mul_inv, ENNReal.inv_pow] at *
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ edist (f n) a ≤ 2 * C * 2⁻¹ ^ n
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ edist (f n) a ≤ C * 2⁻¹ ^ n * 2
tactic: rw [mul_assoc, mul_comm]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ edist (f n) a ≤ C * 2⁻¹ ^ n * 2
state_after: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ C * 2⁻¹ ^ n * 2 = C * 2⁻¹ ^ n / (1 - 2⁻¹)
tactic: convert edist_le_of_edist_le_geometric_of_tendsto 2⁻¹ C hu ha n using 1
state_before: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ C * 2⁻¹ ^ n * 2 = C * 2⁻¹ ^ n / (1 - 2⁻¹)
state_after: no goals
tactic: rw [ENNReal.one_sub_inv_two, div_eq_mul_inv, inv_inv]
Theorem: Metric.isCompact_of_isClosed_isBounded
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
⊢ IsCompact s
state_after: case inl
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed ∅
hb : IsBounded ∅
⊢ IsCompact ∅

case inr.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
x : α
⊢ IsCompact s
tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, -⟩)