ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: _private.Mathlib.Algebra.Order.Ring.Star.0.StarOrderedRing.mul_le_mul_of_nonneg_left
File: Mathlib/Algebra/Order/Ring/Star.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b c : R
hab : a ≤ b
hc : 0 ≤ c
⊢ c * a ≤ c * b
state_after: R : Type u_1
inst✝³ : CommSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b c : R
hab : a ≤ b
hc : c ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
⊢ c * a ≤ c * b
tactic: rw [StarOrderedRing.nonneg_iff] at hc
state_before: R : Type u_1
inst✝³ : CommSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b c : R
hab : a ≤ b
hc : c ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
⊢ c * a ≤ c * b
state_after: no goals
tactic: induction hc using AddSubmonoid.closure_induction' with
  | mem _ h =>
    obtain ⟨x, rfl⟩ := h
    simp_rw [mul_assoc, mul_comm x, ← mul_assoc]
    exact conjugate_le_conjugate hab x
  | one => simp
  | mul x hx y hy =>
    simp only [← nonneg_iff, add_mul] at hx hy ⊢
    apply add_le_add <;> aesop
Theorem: AddSemiconjBy.addUnits_neg_symm_left
File: Mathlib/Algebra/Group/Semiconj/Units.lean

Proof steps:
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : Mˣ
x y : M
h : SemiconjBy (↑a) x y
⊢ ↑a⁻¹ * y = ↑a⁻¹ * (y * ↑a * ↑a⁻¹)
state_after: no goals
tactic: rw [Units.mul_inv_cancel_right]
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : Mˣ
x y : M
h : SemiconjBy (↑a) x y
⊢ ↑a⁻¹ * (y * ↑a * ↑a⁻¹) = x * ↑a⁻¹
state_after: no goals
tactic: rw [← h.eq, ← mul_assoc, Units.inv_mul_cancel_left]
Theorem: Set.monotoneOn_iff_monotone
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ MonotoneOn f s ↔ Monotone fun a => f ↑a
state_after: no goals
tactic: simp [Monotone, MonotoneOn]
Theorem: CategoryTheory.Functor.opUnopEquiv_functor
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
⊢ ∀ {X Y : (C ⥤ D)ᵒᵖ} (f : X ⟶ Y),
    (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) Y).hom =
      ((fun F => (unop F).opUnopIso.op) X).hom ≫ (opHom C D ⋙ opInv C D).map f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) G).hom =
    ((fun F => (unop F).opUnopIso.op) F).hom ≫ (opHom C D ⋙ opInv C D).map f
tactic: intro F G f
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) G).hom =
    ((fun F => (unop F).opUnopIso.op) F).hom ≫ (opHom C D ⋙ opInv C D).map f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ f ≫ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom.op =
    (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom.op ≫
      Quiver.Hom.op { app := fun X => f.unop.app X, naturality := ⋯ }
tactic: dsimp [opUnopIso]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ f ≫ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom.op =
    (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom.op ≫
      Quiver.Hom.op { app := fun X => f.unop.app X, naturality := ⋯ }
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ ((NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop).op =
    ({ app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
        (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom).op
tactic: rw [show f = f.unop.op by simp, ← op_comp, ← op_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ ((NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop).op =
    ({ app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
        (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom).op
state_after: case e_f
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop =
    { app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
      (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom
tactic: congr 1
state_before: case e_f
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop =
    { app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
      (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom
state_after: no goals
tactic: aesop_cat
Theorem: GenContFract.contsAux_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
⊢ g.contsAux m = g.contsAux (n + 1)
state_after: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ k
hk : g.contsAux k = g.contsAux (n + 1)
⊢ g.contsAux (k + 1) = g.contsAux (n + 1)
tactic: refine Nat.le_induction rfl (fun k hnk hk => ?_) _ n_lt_m
state_before: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ k
hk : g.contsAux k = g.contsAux (n + 1)
⊢ g.contsAux (k + 1) = g.contsAux (n + 1)
state_after: case intro
K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ n + k + 1
hk : g.contsAux (n + k + 1) = g.contsAux (n + 1)
⊢ g.contsAux (n + k + 1 + 1) = g.contsAux (n + 1)
tactic: rcases Nat.exists_eq_add_of_lt hnk with ⟨k, rfl⟩
state_before: case intro
K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ n + k + 1
hk : g.contsAux (n + k + 1) = g.contsAux (n + 1)
⊢ g.contsAux (n + k + 1 + 1) = g.contsAux (n + 1)
state_after: case intro
K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ n + k + 1
hk : g.contsAux (n + k + 1) = g.contsAux (n + 1)
⊢ g.TerminatedAt (n + k)
tactic: refine (contsAux_stable_step_of_terminated ?_).trans hk
state_before: case intro
K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_lt_m : n < m
terminatedAt_n : g.TerminatedAt n
k : ℕ
hnk : n.succ ≤ n + k + 1
hk : g.contsAux (n + k + 1) = g.contsAux (n + 1)
⊢ g.TerminatedAt (n + k)
state_after: no goals
tactic: exact terminated_stable (Nat.le_add_right _ _) terminatedAt_n
Theorem: Class.classToCong_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: ⊢ ∅.classToCong = ∅
state_after: case h
x✝ : Class
⊢ x✝ ∈ ∅.classToCong ↔ x✝ ∈ ∅
tactic: ext
state_before: case h
x✝ : Class
⊢ x✝ ∈ ∅.classToCong ↔ x✝ ∈ ∅
state_after: no goals
tactic: simp [classToCong]
Theorem: jacobiTheta₂'_undef
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
hτ : τ.im ≤ 0
⊢ jacobiTheta₂' z τ = 0
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂'_term b z τ
tactic: apply tsum_eq_zero_of_not_summable
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬Summable fun b => jacobiTheta₂'_term b z τ
state_after: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
tactic: rw [summable_jacobiTheta₂'_term_iff]
state_before: case h
z τ : ℂ
hτ : τ.im ≤ 0
⊢ ¬0 < τ.im
state_after: no goals
tactic: exact not_lt.mpr hτ
Theorem: TopCat.pullback_map_embedding_of_embeddings
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ⇑(pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding (⇑(prod.lift (pullback.fst g₁ g₂) (pullback.snd g₁ g₂)) ∘ ⇑(pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))
tactic: refine
    embedding_of_embedding_compose (ContinuousMap.continuous_toFun _)
      (show Continuous (prod.lift (pullback.fst g₁ g₂) (pullback.snd g₁ g₂)) from
        ContinuousMap.continuous_toFun _)
      ?_
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding (⇑(prod.lift (pullback.fst g₁ g₂) (pullback.snd g₁ g₂)) ∘ ⇑(pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ⇑(prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂) ≫ prod.map i₁ i₂)
tactic: suffices
    Embedding (prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂) ≫ Limits.prod.map i₁ i₂) by
    simpa [← coe_comp] using this
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ⇑(prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂) ≫ prod.map i₁ i₂)
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding (⇑(prod.map i₁ i₂) ∘ ⇑(prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂)))
tactic: rw [coe_comp]
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ⇑i₁
H₂ : Embedding ⇑i₂
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding (⇑(prod.map i₁ i₂) ∘ ⇑(prod.lift (pullback.fst f₁ f₂) (pullback.snd f₁ f₂)))
state_after: no goals
tactic: exact Embedding.comp (embedding_prod_map H₁ H₂) (embedding_pullback_to_prod _ _)
Theorem: CategoryTheory.ShortComplex.ShortExact.unop
File: Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
⊢ Mono S.unop.f
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Epi S.g
⊢ Mono S.unop.f
tactic: have := h.epi_g
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Epi S.g
⊢ Mono S.unop.f
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Epi S.g
⊢ Mono S.g.unop
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Epi S.g
⊢ Mono S.g.unop
state_after: no goals
tactic: infer_instance
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
⊢ Epi S.unop.g
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Mono S.f
⊢ Epi S.unop.g
tactic: have := h.mono_f
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Mono S.f
⊢ Epi S.unop.g
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Mono S.f
⊢ Epi S.f.unop
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.4719, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S✝ S₁ S₂ : ShortComplex C
S : ShortComplex Cᵒᵖ
h : S.ShortExact
this : Mono S.f
⊢ Epi S.f.unop
state_after: no goals
tactic: infer_instance
Theorem: uniformInducing_iff'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ UniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ 𝓤 α ≤ comap (fun x => (f x.1, f x.2)) (𝓤 β) ∧ comap (fun x => (f x.1, f x.2)) (𝓤 β) ≤ 𝓤 α ↔
    𝓤 α ≤ comap (fun x => (f x.1, f x.2)) (𝓤 β) ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
tactic: rw [uniformInducing_iff, UniformContinuous, tendsto_iff_comap, le_antisymm_iff, and_comm]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ 𝓤 α ≤ comap (fun x => (f x.1, f x.2)) (𝓤 β) ∧ comap (fun x => (f x.1, f x.2)) (𝓤 β) ≤ 𝓤 α ↔
    𝓤 α ≤ comap (fun x => (f x.1, f x.2)) (𝓤 β) ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
state_after: no goals
tactic: rfl
Theorem: Set.add_mem_addCentralizer
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : Semigroup M
a b : M
ha : a ∈ S.centralizer
hb : b ∈ S.centralizer
g : M
hg : g ∈ S
⊢ g * (a * b) = a * b * g
state_after: no goals
tactic: rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
Theorem: Nat.preimage_Iic
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
⊢ Nat.cast ⁻¹' Iic a = Iic ⌊a⌋₊
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋₊
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Iic a ↔ x✝ ∈ Iic ⌊a⌋₊
state_after: no goals
tactic: simp [le_floor_iff, ha]
Theorem: SeparatingDual.t1Space
File: Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
⊢ T1Space V
state_after: R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U
tactic: apply t1Space_iff_exists_open.2 (fun x y hxy ↦ ?_)
state_before: R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U
state_after: case intro
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
f : V →L[R] R
hf : f x ≠ f y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U
tactic: rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
state_before: case intro
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
f : V →L[R] R
hf : f x ≠ f y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U
state_after: no goals
tactic: exact ⟨f ⁻¹' {f y}ᶜ, isOpen_compl_singleton.preimage f.continuous, hf, by simp⟩
Theorem: Pi.mulSingle_apply_commute
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))
state_after: case inl
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i : I
⊢ Commute (mulSingle i (x i)) (mulSingle i (x i))

case inr
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
hij : i ≠ j
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))
tactic: obtain rfl | hij := Decidable.eq_or_ne i j
Theorem: subset_exterior_iff
File: Mathlib/Topology/AlexandrovDiscrete.lean

Proof steps:
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a x y : α
⊢ s ⊆ exterior t ↔ ∀ (U : Set α), IsOpen U → t ⊆ U → s ⊆ U
state_after: no goals
tactic: simp [exterior_def]
Theorem: CategoryTheory.NatTrans.app_sum
File: Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{u_4, u_2} D
inst✝ : Preadditive D
F G : C ⥤ D
ι : Type u_3
s : Finset ι
X : C
α : ι → (F ⟶ G)
⊢ (∑ i ∈ s, α i).app X = ∑ i ∈ s, (α i).app X
state_after: no goals
tactic: simp only [← appHom_apply, map_sum]
Theorem: closure_Ioo
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioo a b) = Icc a b
state_after: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioo a b) ⊆ Icc a b

case h₂
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioo a b)
tactic: apply Subset.antisymm
Theorem: Nat.modEq_iff_dvd
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
⊢ a ≡ b [MOD n] ↔ ↑n ∣ ↑b - ↑a
state_after: no goals
tactic: rw [ModEq, eq_comm, ← Int.natCast_inj, Int.natCast_mod, Int.natCast_mod,
    Int.emod_eq_emod_iff_emod_sub_eq_zero, Int.dvd_iff_emod_eq_zero]
Theorem: List.Nodup.sigma
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a✝ b✝ : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a : α
x✝ : a ∈ l₁
b b' : σ a
h : ⟨a, b⟩ = ⟨a, b'⟩
⊢ b = b'
state_after: no goals
tactic: injection h with _ h
state_before: α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
x : (a : α) × σ a
h₁ : x ∈ map (Sigma.mk a₁) (l₂ a₁)
h₂ : x ∈ map (Sigma.mk a₂) (l₂ a₂)
⊢ False
state_after: case intro.intro
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
h₂ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₂) (l₂ a₂)
⊢ False
tactic: rcases mem_map.1 h₁ with ⟨b₁, _, rfl⟩
state_before: case intro.intro
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a₁ a₂ : α
n : a₁ ≠ a₂
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
h₂ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₂) (l₂ a₂)
⊢ False
state_after: case intro.intro.intro.intro.refl
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a₁ : α
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
n : a₁ ≠ a₁
h₂ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
mb₂ : b₁ ∈ l₂ a₁
⊢ False
tactic: rcases mem_map.1 h₂ with ⟨b₂, mb₂, ⟨⟩⟩
state_before: case intro.intro.intro.intro.refl
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
σ : α → Type u_1
l₂ : (a : α) → List (σ a)
d₁ : l₁.Nodup
d₂ : ∀ (a : α), (l₂ a).Nodup
a₁ : α
b₁ : σ a₁
left✝ : b₁ ∈ l₂ a₁
h₁ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
n : a₁ ≠ a₁
h₂ : ⟨a₁, b₁⟩ ∈ map (Sigma.mk a₁) (l₂ a₁)
mb₂ : b₁ ∈ l₂ a₁
⊢ False
state_after: no goals
tactic: exact n rfl
Theorem: Complex.ofReal_mem_slitPlane
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ ↑x ∈ slitPlane ↔ 0 < x
state_after: no goals
tactic: simp [mem_slitPlane_iff]
Theorem: toIcoMod_eq_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a b = toIcoMod hp 0 (b - a) + a
state_after: no goals
tactic: rw [toIcoMod_sub_eq_sub, zero_add, sub_add_cancel]
Theorem: ZMod.val_injective
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
⊢ Injective val
state_after: case zero
m n : ℕ
inst✝ : NeZero 0
⊢ Injective val

case succ
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Injective val
tactic: cases n
state_before: case succ
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Injective val
state_after: case succ
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ a = b
tactic: intro a b h
state_before: case succ
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ a = b
state_after: case succ.h
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ ↑a = ↑b
tactic: ext
state_before: case succ.h
m n n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
a b : ZMod (n✝ + 1)
h : a.val = b.val
⊢ ↑a = ↑b
state_after: no goals
tactic: exact h
Theorem: frontier_Iic'
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
ha : (Ioi a).Nonempty
⊢ frontier (Iic a) = {a}
state_after: no goals
tactic: simp [frontier, ha]