ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Cardinal.nat_add_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
n : ℕ
⊢ ↑n + ℵ₀ = ℵ₀
state_after: no goals
tactic: rw [add_comm, aleph0_add_nat]
Theorem: Real.hasStrictDerivAt_const_rpow_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: x✝ y z a x : ℝ
ha : a < 0
⊢ HasStrictDerivAt (fun x => a ^ x) (a ^ x * log a - rexp (log a * x) * sin (x * π) * π) x
state_after: no goals
tactic: simpa using (hasStrictFDerivAt_rpow_of_neg (a, x) ha).comp_hasStrictDerivAt x
    ((hasStrictDerivAt_const _ _).prod (hasStrictDerivAt_id _))
Theorem: Function.FromTypes.uncurry_curry
File: Mathlib/Data/Fin/Tuple/Curry.lean

Proof steps:
state_before: n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
⊢ (curry f).uncurry = f
state_after: case h
n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
args : (i : Fin n) → p i
⊢ (curry f).uncurry args = f args
tactic: ext args
state_before: case h
n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
args : (i : Fin n) → p i
⊢ (curry f).uncurry args = f args
state_after: no goals
tactic: induction n with
  | zero => exact congrArg f (Subsingleton.allEq _ _)
  | succ n ih => exact Eq.trans (ih _ _) (congrArg f (Fin.cons_self_tail args))
Theorem: LazyList.append_nil
File: .lake/packages/batteries/Batteries/Data/LazyList.lean

Proof steps:
state_before: α : Type u_1
xs : LazyList α
⊢ xs.append (Thunk.pure nil) = xs
state_after: no goals
tactic: induction xs using LazyList.rec with
  | nil => simp only [Thunk.pure, append, Thunk.get]
  | cons _ _ => simpa only [append, cons.injEq, true_and]
  | mk _ ih => ext; apply ih
Theorem: lipschitz_with_lipschitz_const_add
File: Mathlib/Topology/MetricSpace/Algebra.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : Monoid β
inst✝ : LipschitzMul β
⊢ ∀ (p q : β × β), dist (p.1 * p.2) (q.1 * q.2) ≤ ↑(LipschitzMul.C β) * dist p q
state_after: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : Monoid β
inst✝ : LipschitzMul β
⊢ LipschitzWith (LipschitzMul.C β) fun p => p.1 * p.2
tactic: rw [← lipschitzWith_iff_dist_le_mul]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : Monoid β
inst✝ : LipschitzMul β
⊢ LipschitzWith (LipschitzMul.C β) fun p => p.1 * p.2
state_after: no goals
tactic: exact lipschitzWith_lipschitz_const_mul_edist
Theorem: SimpleGraph.Walk.map_id
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ p : G.Walk u v
⊢ Walk.map Hom.id p = p
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons _ p' ih => simp [ih p']
Theorem: IsLocalization.isNoetherianRing
File: Mathlib/RingTheory/Localization/Submodule.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
P : Type u_3
inst✝⁴ : CommRing P
g : R →+* P
T : Submonoid P
hy : M ≤ Submonoid.comap g T
Q : Type u_4
inst✝³ : CommRing Q
inst✝² : Algebra P Q
inst✝¹ : IsLocalization T Q
inst✝ : IsLocalization M S
h : IsNoetherianRing R
⊢ IsNoetherianRing S
state_after: R : Type u_1
inst✝⁷ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
P : Type u_3
inst✝⁴ : CommRing P
g : R →+* P
T : Submonoid P
hy : M ≤ Submonoid.comap g T
Q : Type u_4
inst✝³ : CommRing Q
inst✝² : Algebra P Q
inst✝¹ : IsLocalization T Q
inst✝ : IsLocalization M S
h : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun x x_1 => x > x_1
tactic: rw [isNoetherianRing_iff, isNoetherian_iff_wellFounded] at h ⊢
state_before: R : Type u_1
inst✝⁷ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
P : Type u_3
inst✝⁴ : CommRing P
g : R →+* P
T : Submonoid P
hy : M ≤ Submonoid.comap g T
Q : Type u_4
inst✝³ : CommRing Q
inst✝² : Algebra P Q
inst✝¹ : IsLocalization T Q
inst✝ : IsLocalization M S
h : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun x x_1 => x > x_1
state_after: no goals
tactic: exact OrderEmbedding.wellFounded (IsLocalization.orderEmbedding M S).dual h
Theorem: xor_true
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: a b : Prop
⊢ Xor' True = Not
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) [Xor']
Theorem: Polynomial.valuation_of_mk
File: Mathlib/FieldTheory/RatFunc/AsPolynomial.lean

Proof steps:
state_before: K✝ : Type u
K : Type u_1
inst✝ : Field K
f g : K[X]
hg : g ≠ 0
⊢ (idealX K).valuation (RatFunc.mk f g) = (idealX K).intValuation f / (idealX K).intValuation g
state_after: no goals
tactic: simp only [RatFunc.mk_eq_mk' _ hg, valuation_of_mk']
Theorem: List.lookmap_id'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
h : ∀ (a b : α), b ∈ f a → a = b
l : List α
⊢ lookmap f l = l
state_after: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
h : ∀ (a b : α), b ∈ f a → a = b
l : List α
⊢ ∀ (a b : α), b ∈ f a → id a = id b
tactic: rw [← map_id (l.lookmap f), lookmap_map_eq, map_id]
state_before: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
h : ∀ (a b : α), b ∈ f a → a = b
l : List α
⊢ ∀ (a b : α), b ∈ f a → id a = id b
state_after: no goals
tactic: exact h
Theorem: Polynomial.taylor_coeff
File: Mathlib/Algebra/Polynomial/Taylor.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n : ℕ
⊢ (lcoeff R n ∘ₗ taylor r) f = (leval r ∘ₗ hasseDeriv n) f
state_after: case e_a
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n : ℕ
⊢ lcoeff R n ∘ₗ taylor r = leval r ∘ₗ hasseDeriv n
tactic: congr 1
state_before: case e_a
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n : ℕ
⊢ lcoeff R n ∘ₗ taylor r = leval r ∘ₗ hasseDeriv n
state_after: case e_a
R : Type u_1
inst✝ : Semiring R
r : R
n : ℕ
⊢ lcoeff R n ∘ₗ taylor r = leval r ∘ₗ hasseDeriv n
tactic: clear! f
state_before: case e_a
R : Type u_1
inst✝ : Semiring R
r : R
n : ℕ
⊢ lcoeff R n ∘ₗ taylor r = leval r ∘ₗ hasseDeriv n
state_after: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ ((lcoeff R n ∘ₗ taylor r) ∘ₗ monomial i) 1 = ((leval r ∘ₗ hasseDeriv n) ∘ₗ monomial i) 1
tactic: ext i
state_before: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ ((lcoeff R n ∘ₗ taylor r) ∘ₗ monomial i) 1 = ((leval r ∘ₗ hasseDeriv n) ∘ₗ monomial i) 1
state_after: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ ∑ x ∈ Finset.range (i + 1), (lcoeff R n) (X ^ x * C r ^ (i - x) * ↑(i.choose x)) = ↑(i.choose n) * r ^ (i - n)
tactic: simp only [leval_apply, mul_one, one_mul, eval_monomial, LinearMap.comp_apply, coeff_C_mul,
      hasseDeriv_monomial, taylor_apply, monomial_comp, C_1, (commute_X (C r)).add_pow i,
      map_sum]
state_before: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ ∑ x ∈ Finset.range (i + 1), (lcoeff R n) (X ^ x * C r ^ (i - x) * ↑(i.choose x)) = ↑(i.choose n) * r ^ (i - n)
state_after: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ (if n < i + 1 then r ^ (i - n) * ↑(i.choose n) else 0) = r ^ (i - n) * ↑(i.choose n)
tactic: simp only [lcoeff_apply, ← C_eq_natCast, mul_assoc, ← C_pow, ← C_mul, coeff_mul_C,
      (Nat.cast_commute _ _).eq, coeff_X_pow, boole_mul, Finset.sum_ite_eq, Finset.mem_range]
state_before: case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ (if n < i + 1 then r ^ (i - n) * ↑(i.choose n) else 0) = r ^ (i - n) * ↑(i.choose n)
state_after: case pos
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : n < i + 1
⊢ r ^ (i - n) * ↑(i.choose n) = r ^ (i - n) * ↑(i.choose n)

case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : ¬n < i + 1
⊢ 0 = r ^ (i - n) * ↑(i.choose n)
tactic: split_ifs with h
state_before: case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : ¬n < i + 1
⊢ 0 = r ^ (i - n) * ↑(i.choose n)
state_after: case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : i + 1 ≤ n
⊢ 0 = r ^ (i - n) * ↑(i.choose n)
tactic: push_neg at h
state_before: case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : i + 1 ≤ n
⊢ 0 = r ^ (i - n) * ↑(i.choose n)
state_after: no goals
tactic: rw [Nat.choose_eq_zero_of_lt h, Nat.cast_zero, mul_zero]
Theorem: Homeomorph.locallyConnectedSpace
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
⊢ LocallyConnectedSpace X
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
x✝¹ : X
x✝ : Set Y
hs : IsOpen x✝ ∧ h x✝¹ ∈ x✝ ∧ IsConnected x✝
⊢ IsPreconnected (⇑h.symm '' x✝)
tactic: refine locallyConnectedSpace_of_connected_bases _ _ this fun _ _ hs ↦ ?_
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
i : LocallyConnectedSpace Y
h : X ≃ₜ Y
this : ∀ (x : X), (𝓝 x).HasBasis (fun s => IsOpen s ∧ h x ∈ s ∧ IsConnected s) fun x => ⇑h.symm '' x
x✝¹ : X
x✝ : Set Y
hs : IsOpen x✝ ∧ h x✝¹ ∈ x✝ ∧ IsConnected x✝
⊢ IsPreconnected (⇑h.symm '' x✝)
state_after: no goals
tactic: exact hs.2.2.2.image _ h.symm.continuous.continuousOn
Theorem: CategoryTheory.Limits.spanExt_hom_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).hom.app WalkingSpan.left = iY.hom
state_after: no goals
tactic: dsimp [spanExt]
Theorem: AddCommGroup.modEq_sub_iff_add_modEq'
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p]
state_after: no goals
tactic: simp [ModEq, sub_sub]
Theorem: ContinuousLinearMap.continuous_toWOT
File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Continuous ⇑(toWOT 𝕜 E F)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (((toWOT 𝕜 E F) a) x)
tactic: refine ContinuousLinearMapWOT.continuous_of_dual_apply_continuous fun x y => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (((toWOT 𝕜 E F) a) x)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (a x)
tactic: simp_rw [ContinuousLinearMap.toWOT_apply]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (a x)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (((id 𝕜 (E →L[𝕜] F)).flip x) a)
tactic: change Continuous fun a => y <| (ContinuousLinearMap.id 𝕜 (E →L[𝕜] F)).flip x a
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : E
y : NormedSpace.Dual 𝕜 F
⊢ Continuous fun a => y (((id 𝕜 (E →L[𝕜] F)).flip x) a)
state_after: no goals
tactic: fun_prop
Theorem: CategoryTheory.GrothendieckTopology.Plus.isSheaf_plus_plus
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

Proof steps:
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
P : Cᵒᵖ ⥤ D
⊢ Presheaf.IsSheaf J (J.plusObj (J.plusObj P))
state_after: case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
P : Cᵒᵖ ⥤ D
⊢ ∀ (X : C) (S : J.Cover X) (x y : (forget D).obj ((J.plusObj P).obj (op X))),
    (∀ (I : S.Arrow), ((J.plusObj P).map I.f.op) x = ((J.plusObj P).map I.f.op) y) → x = y
tactic: apply isSheaf_of_sep
state_before: case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
P : Cᵒᵖ ⥤ D
⊢ ∀ (X : C) (S : J.Cover X) (x y : (forget D).obj ((J.plusObj P).obj (op X))),
    (∀ (I : S.Arrow), ((J.plusObj P).map I.f.op) x = ((J.plusObj P).map I.f.op) y) → x = y
state_after: case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
P : Cᵒᵖ ⥤ D
X : C
S : J.Cover X
x y : (forget D).obj ((J.plusObj P).obj (op X))
⊢ (∀ (I : S.Arrow), ((J.plusObj P).map I.f.op) x = ((J.plusObj P).map I.f.op) y) → x = y
tactic: intro X S x y
state_before: case hsep
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category.{max v u, w} D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
inst✝ : (forget D).ReflectsIsomorphisms
P : Cᵒᵖ ⥤ D
X : C
S : J.Cover X
x y : (forget D).obj ((J.plusObj P).obj (op X))
⊢ (∀ (I : S.Arrow), ((J.plusObj P).map I.f.op) x = ((J.plusObj P).map I.f.op) y) → x = y
state_after: no goals
tactic: apply sep
Theorem: Inducing.firstCountableTopology
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
t : TopologicalSpace α
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : FirstCountableTopology β
f : α → β
hf : Inducing f
⊢ FirstCountableTopology α
state_after: no goals
tactic: exact firstCountableTopology_induced α β f
Theorem: Matroid.Base.base_of_basis_superset
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hB : M.Base B
hBX : B ⊆ X
hIX : M.Basis I X
⊢ M.Base I
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hB : M.Base B
hBX : B ⊆ X
hIX : M.Basis I X
h : ¬M.Base I
⊢ False
tactic: by_contra h
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hB : M.Base B
hBX : B ⊆ X
hIX : M.Basis I X
h : ¬M.Base I
⊢ False
state_after: case intro.intro
α : Type u_1
M : Matroid α
B I J X Y : Set α
e✝ : α
hB : M.Base B
hBX : B ⊆ X
hIX : M.Basis I X
h : ¬M.Base I
e : α
heBI : e ∈ B \ I
he : M.Indep (insert e I)
⊢ False
tactic: obtain ⟨e,heBI,he⟩ := hIX.indep.exists_insert_of_not_base h hB
state_before: case intro.intro
α : Type u_1
M : Matroid α
B I J X Y : Set α
e✝ : α
hB : M.Base B
hBX : B ⊆ X
hIX : M.Basis I X
h : ¬M.Base I
e : α
heBI : e ∈ B \ I
he : M.Indep (insert e I)
⊢ False
state_after: no goals
tactic: exact heBI.2 (hIX.mem_of_insert_indep (hBX heBI.1) he)
Theorem: toIcoMod_eq_iff
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 : ℤ
⊢ toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p) → toIcoMod hp a b = c
tactic: refine
    ⟨fun h =>
      ⟨h ▸ toIcoMod_mem_Ico hp a b, toIcoDiv hp a b, h ▸ (toIcoMod_add_toIcoDiv_zsmul _ _ _).symm⟩,
      ?_⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p) → toIcoMod hp a b = c
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b - z • p = c) → toIcoMod hp a b = c
tactic: simp_rw [← @sub_eq_iff_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ico a (a + p) ∧ ∃ z, b - z • p = c) → toIcoMod hp a b = c
state_after: case intro.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
n✝ n : ℤ
hc : b - n • p ∈ Set.Ico a (a + p)
⊢ toIcoMod hp a b = b - n • p
tactic: rintro ⟨hc, n, rfl⟩
state_before: case intro.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
n✝ n : ℤ
hc : b - n • p ∈ Set.Ico a (a + p)
⊢ toIcoMod hp a b = b - n • p
state_after: no goals
tactic: rw [← toIcoDiv_eq_of_sub_zsmul_mem_Ico hp hc, toIcoMod]
Theorem: Monotone.tendsto_le_alternating_series
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
⊢ l ≤ ∑ i ∈ Finset.range (2 * k), (-1) ^ i * f i
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
ha : Antitone fun n => ∑ i ∈ Finset.range (2 * n), (-1) ^ i * f i
⊢ l ≤ ∑ i ∈ Finset.range (2 * k), (-1) ^ i * f i
tactic: have ha : Antitone (fun n ↦ ∑ i ∈ range (2 * n), (-1) ^ i * f i) := by
    refine antitone_nat_of_succ_le (fun n ↦ ?_)
    rw [show 2 * (n + 1) = 2 * n + 1 + 1 by ring, sum_range_succ, sum_range_succ]
    simp_rw [_root_.pow_succ', show (-1 : E) ^ (2 * n) = 1 by simp, neg_one_mul, one_mul,
      ← sub_eq_add_neg, sub_le_iff_le_add]
    gcongr
    exact hfm (by omega)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
ha : Antitone fun n => ∑ i ∈ Finset.range (2 * n), (-1) ^ i * f i
⊢ l ≤ ∑ i ∈ Finset.range (2 * k), (-1) ^ i * f i
state_after: no goals
tactic: exact ha.le_of_tendsto (hfl.comp (tendsto_atTop_mono (fun n ↦ by dsimp; omega) tendsto_id)) _
Theorem: Complex.tendsto_log_nhdsWithin_im_neg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto log (𝓝[{z | z.im < 0}] z) (𝓝 (↑(Real.log (abs z)) - ↑π * I))
state_after: case h.e'_5
z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ 𝓝 (↑(Real.log (abs z)) - ↑π * I) = 𝓝 ((ofReal' ∘ fun x => Real.log (abs x)) z + ↑(-π) * I)

case convert_1
z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ abs z ≠ 0
tactic: convert
    (continuous_ofReal.continuousAt.comp_continuousWithinAt
            (continuous_abs.continuousWithinAt.log _)).tendsto.add
      (((continuous_ofReal.tendsto _).comp <|
            tendsto_arg_nhdsWithin_im_neg_of_re_neg_of_im_zero hre him).mul
        tendsto_const_nhds) using 1
Theorem: NumberField.mixedEmbedding.convexBodySumFun_apply'
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ convexBodySumFun x = ∑ w : { w // w.IsReal }, ‖x.1 w‖ + 2 * ∑ w : { w // w.IsComplex }, ‖x.2 w‖
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ ∑ x_1 ∈ Finset.subtype IsReal Finset.univ, ↑(↑x_1).mult * (normAtPlace ↑x_1) x +
      ∑ x_1 ∈ Finset.subtype (fun x => x.IsComplex) Finset.univ, ↑(↑x_1).mult * (normAtPlace ↑x_1) x =
    ∑ x_1 ∈ Finset.subtype IsReal Finset.univ, ‖x.1 x_1‖ + ∑ i ∈ Finset.subtype IsComplex Finset.univ, 2 * ‖x.2 i‖
tactic: simp_rw [convexBodySumFun_apply, ← Finset.sum_add_sum_compl {w | IsReal w}.toFinset,
    Set.toFinset_setOf, Finset.compl_filter, not_isReal_iff_isComplex, ← Finset.subtype_univ,
    ← Finset.univ.sum_subtype_eq_sum_filter, Finset.mul_sum]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ ∑ x_1 ∈ Finset.subtype IsReal Finset.univ, ↑(↑x_1).mult * (normAtPlace ↑x_1) x +
      ∑ x_1 ∈ Finset.subtype (fun x => x.IsComplex) Finset.univ, ↑(↑x_1).mult * (normAtPlace ↑x_1) x =
    ∑ x_1 ∈ Finset.subtype IsReal Finset.univ, ‖x.1 x_1‖ + ∑ i ∈ Finset.subtype IsComplex Finset.univ, 2 * ‖x.2 i‖
state_after: case e_a.e_f
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ (fun x_1 => ↑(↑x_1).mult * (normAtPlace ↑x_1) x) = fun x_1 => ‖x.1 x_1‖

case e_a.e_f
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ (fun x_1 => ↑(↑x_1).mult * (normAtPlace ↑x_1) x) = fun i => 2 * ‖x.2 i‖
tactic: congr
Theorem: PiCountable.min_dist_le_dist_pi
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
ι : Type u_2
inst✝¹ : Encodable ι
F : ι → Type u_3
inst✝ : (i : ι) → MetricSpace (F i)
x y : (i : ι) → F i
i j : ι
x✝ : j ≠ i
⊢ 0 ≤ (1 / 2) ^ encode j
state_after: no goals
tactic: simp
Theorem: Monotone.partSeq
File: Mathlib/Order/Part.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
inst✝ : Preorder α
β γ : Type u_4
f : α → Part (β → γ)
g : α → Part β
hf : Monotone f
hg : Monotone g
⊢ Monotone fun x => Seq.seq (f x) fun x_1 => g x
state_after: no goals
tactic: simpa only [seq_eq_bind_map] using hf.partBind $ Monotone.of_apply₂ fun _ ↦ hg.partMap