ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Metric.tendstoUniformlyOnFilter_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
⊢ TendstoUniformlyOnFilter F f p p' ↔ ∀ ε > 0, ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.2) (F n.1 n.2) < ε
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ ε > 0, ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.2) (F n.1 n.2) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.2, F n.1 n.2) ∈ u
tactic: refine ⟨fun H ε hε => H _ (dist_mem_uniformity hε), fun H u hu => ?_⟩
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ ε > 0, ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.2) (F n.1 n.2) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.2, F n.1 n.2) ∈ u
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ ε > 0, ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.2) (F n.1 n.2) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.2, F n.1 n.2) ∈ u
tactic: rcases mem_uniformity_dist.1 hu with ⟨ε, εpos, hε⟩
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
F : ι → β → α
f : β → α
p : Filter ι
p' : Filter β
H : ∀ ε > 0, ∀ᶠ (n : ι × β) in p ×ˢ p', dist (f n.2) (F n.1 n.2) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι × β) in p ×ˢ p', (f n.2, F n.1 n.2) ∈ u
state_after: no goals
tactic: exact (H ε εpos).mono fun n hn => hε hn
Theorem: Polynomial.X_pow_sub_one_splits
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
ζ : K
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ Splits (RingHom.id K) (X ^ n - C 1)
state_after: no goals
tactic: rw [splits_iff_card_roots, ← nthRoots, IsPrimitiveRoot.card_nthRoots_one h, natDegree_X_pow_sub_C]
Theorem: ContinuousMap.nonUnitalStarAlgebraAdjoin_id_subset_ker_evalStarAlgHom
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
h0 : 0 ∈ s
⊢ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)}) ⊆ ↑(RingHom.ker (evalStarAlgHom 𝕜 𝕜 ⟨0, h0⟩))
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
h0 : 0 ∈ s
f : C(↑s, 𝕜)
hf : f ∈ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)})
⊢ f ∈ ↑(RingHom.ker (evalStarAlgHom 𝕜 𝕜 ⟨0, h0⟩))
tactic: intro f hf
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
𝕜 : Type u_2
inst✝ : RCLike 𝕜
s : Set 𝕜
h0 : 0 ∈ s
f : C(↑s, 𝕜)
hf : f ∈ ↑(adjoin 𝕜 {restrict s (ContinuousMap.id 𝕜)})
⊢ f ∈ ↑(RingHom.ker (evalStarAlgHom 𝕜 𝕜 ⟨0, h0⟩))
state_after: no goals
tactic: induction hf using adjoin_induction' with
  | mem f hf =>
    obtain rfl := Set.mem_singleton_iff.mp hf
    rfl
  | add f _ g _ hf hg => exact add_mem hf hg
  | zero => exact zero_mem _
  | mul f _ g _ _ hg => exact Ideal.mul_mem_left _ f hg
  | smul r f _ hf =>
    rw [SetLike.mem_coe, RingHom.mem_ker] at hf ⊢
    rw [map_smul, hf, smul_zero]
  | star f _ hf =>
    rw [SetLike.mem_coe, RingHom.mem_ker] at hf ⊢
    rw [map_star, hf, star_zero]
Theorem: CategoryTheory.Presheaf.isSheaf_iff_preservesFiniteProducts_of_projective
File: Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.41105, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
inst✝ : ∀ (X : C), Projective X
⊢ IsSheaf (coherentTopology C) F ↔ Nonempty (PreservesFiniteProducts F)
state_after: no goals
tactic: rw [isSheaf_coherent_iff_regular_and_extensive, and_iff_left (isSheaf_of_projective F),
    isSheaf_iff_preservesFiniteProducts]
Theorem: HasSum.mul_right
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂✝ a₂ : α
hf : HasSum f a₁
⊢ HasSum (fun i => f i * a₂) (a₁ * a₂)
state_after: no goals
tactic: simpa only using hf.map (AddMonoidHom.mulRight a₂) (continuous_id.mul continuous_const)
Theorem: sub_add_comm
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = c / b * a
state_after: no goals
tactic: simp
Theorem: Finsupp.neLocus_self_add_left
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ (f + g).neLocus f = g.support
state_after: no goals
tactic: rw [neLocus_comm, neLocus_self_add_right]
Theorem: HasDerivAt.clog_real
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℂ
x : ℝ
f' : ℂ
h₁ : HasDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasDerivAt (fun t => log (f t)) (f' / f x) x
state_after: no goals
tactic: simpa only [div_eq_inv_mul] using
    (hasStrictFDerivAt_log_real h₂).hasFDerivAt.comp_hasDerivAt x h₁
Theorem: pow_natAbs_eq_one
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a ^ n.natAbs = 1 ↔ a ^ n = 1
state_after: no goals
tactic: cases n <;> simp
Theorem: Polynomial.C_mul_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ (C a * p).comp r = C a * p.comp r
state_after: no goals
tactic: induction p using Polynomial.induction_on' with
  | h_add p q hp hq =>
    simp [hp, hq, mul_add]
  | h_monomial n b =>
    simp [mul_assoc]
Theorem: Multiset.coe_sigma
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ : α → Type u_4
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ ((↑l₁).sigma fun a => ↑(l₂ a)) = ↑(l₁.sigma l₂)
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ : α → Type u_4
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ ((↑l₁).bind fun a => map (Sigma.mk a) ↑(l₂ a)) = (↑l₁).bind fun a => ↑(List.map (Sigma.mk a) (l₂ a))
tactic: rw [Multiset.sigma, List.sigma, ← coe_bind]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ : α → Type u_4
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ ((↑l₁).bind fun a => map (Sigma.mk a) ↑(l₂ a)) = (↑l₁).bind fun a => ↑(List.map (Sigma.mk a) (l₂ a))
state_after: no goals
tactic: simp
Theorem: IsClosedMap.of_inverse
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f '' s)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f' ⁻¹' s)
tactic: rw [image_eq_preimage_of_inverse r_inv l_inv]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f' : Y → X
h : Continuous f'
l_inv : LeftInverse f f'
r_inv : Function.RightInverse f f'
s : Set X
hs : IsClosed s
⊢ IsClosed (f' ⁻¹' s)
state_after: no goals
tactic: exact hs.preimage h
Theorem: singleton_mul_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} * ball 1 δ = ball x δ
state_after: no goals
tactic: simp
Theorem: RelEmbedding.inter_preimage_minimals_eq
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x✝ : α
f✝ : α → β
r : α → α → Prop
s : β → β → Prop
f : r ↪r s
x : Set α
y : Set β
⊢ ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
state_after: no goals
tactic: simp [f.map_rel_iff]
Theorem: Filter.frequently_or_distrib_right
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : f.NeBot
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∨ q) ↔ (∃ᶠ (x : α) in f, p x) ∨ q
state_after: no goals
tactic: simp
Theorem: MeasureTheory.log_rnDeriv_tilted_left_self
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : Integrable (fun x => rexp (f x)) μ
⊢ (fun x => log ((μ.tilted f).rnDeriv μ x).toReal) =ᶠ[ae μ] fun x => f x - log (∫ (x : α), rexp (f x) ∂μ)
state_after: no goals
tactic: cases eq_zero_or_neZero μ with
  | inl h => simp_rw [h, ae_zero, Filter.EventuallyEq]; exact Filter.eventually_bot
  | inr h0 =>
    have hf' : AEMeasurable f μ := aemeasurable_of_aemeasurable_exp hf.1.aemeasurable
    filter_upwards [rnDeriv_tilted_left_self hf'] with x hx
    rw [hx, ENNReal.toReal_ofReal (by positivity), log_div (exp_pos _).ne', log_exp]
    exact (integral_exp_pos hf).ne'
Theorem: WeierstrassCurve.Jacobian.nonsingularLift_addMap
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : PointClass F
hP : W.NonsingularLift P
hQ : W.NonsingularLift Q
⊢ W.NonsingularLift (W.addMap P Q)
state_after: case mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : PointClass F
hQ : W.NonsingularLift Q
a✝ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.addMap (Quot.mk Setoid.r a✝) Q)
tactic: rcases P
state_before: case mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : PointClass F
hQ : W.NonsingularLift Q
a✝ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.addMap (Quot.mk Setoid.r a✝) Q)
state_after: case mk.mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : PointClass F
a✝¹ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝¹)
a✝ : Fin 3 → F
hQ : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.addMap (Quot.mk Setoid.r a✝¹) (Quot.mk Setoid.r a✝))
tactic: rcases Q
state_before: case mk.mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : PointClass F
a✝¹ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝¹)
a✝ : Fin 3 → F
hQ : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.addMap (Quot.mk Setoid.r a✝¹) (Quot.mk Setoid.r a✝))
state_after: no goals
tactic: exact nonsingular_add hP hQ
Theorem: SetTheory.PGame.wf_isOption
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: x✝ x : PGame
IHl : ∀ (i : x.LeftMoves), Acc IsOption (x.moveLeft i)
IHr : ∀ (j : x.RightMoves), Acc IsOption (x.moveRight j)
y : PGame
h : y.IsOption x
⊢ Acc IsOption y
state_after: case moveLeft
x✝¹ x y x✝ : PGame
i : x✝.LeftMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveLeft i)

case moveRight
x✝¹ x y x✝ : PGame
j : x✝.RightMoves
IHl : ∀ (i : x✝.LeftMoves), Acc IsOption (x✝.moveLeft i)
IHr : ∀ (j : x✝.RightMoves), Acc IsOption (x✝.moveRight j)
⊢ Acc IsOption (x✝.moveRight j)
tactic: induction' h with _ i _ j
Theorem: List.mem_eraseP_of_neg
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
⊢ a ∈ eraseP p l ↔ a ∈ l
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
⊢ a ∈ eraseP p l
tactic: refine ⟨mem_of_mem_eraseP, fun al => ?_⟩
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
⊢ a ∈ eraseP p l
state_after: no goals
tactic: match exists_or_eq_self_of_eraseP p l with
  | .inl h => rw [h]; assumption
  | .inr ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ =>
    rw [h₄]; rw [h₃] at al
    have : a ≠ c := fun h => (h ▸ pa).elim h₂
    simp [this] at al; simp [al]
Theorem: RatFunc.laurentAux_div
File: Mathlib/FieldTheory/Laurent.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ R[X]⁰ ≤ Submonoid.comap { toFun := ⇑(taylor r), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ } R[X]⁰
state_after: no goals
tactic: exact taylor_mem_nonZeroDivisors r
Theorem: two_mul_le_add_sq
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : CommSemiring α
inst✝⁴ : LinearOrder α
a✝ b✝ c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosStrictMono α
inst✝¹ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ 2 * a * b ≤ a ^ 2 + b ^ 2
state_after: no goals
tactic: simpa [fn_min_add_fn_max (fun x ↦ x * x), sq, two_mul, add_mul]
    using mul_add_mul_le_mul_add_mul (@min_le_max _ _ a b) (@min_le_max _ _ a b)
Theorem: LieDerivation.leibniz_lie
File: Mathlib/Algebra/Lie/Derivation/Basic.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆
state_after: case H
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
y : L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ y = (⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆) y
tactic: ext y
state_before: case H
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
D₁ D₂ : LieDerivation R L L
y : L
⊢ ⁅x, ⁅D₁, D₂⁆⁆ y = (⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆) y
state_after: no goals
tactic: simp [-lie_skew, ← lie_skew (D₁ x) (D₂ y), ← lie_skew (D₂ x) (D₁ y), sub_eq_neg_add]
Theorem: Finset.sum_Ico_eq_add_neg
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
δ : Type u_3
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ (∏ k ∈ Ico m n, f k) * ∏ k ∈ range m, f k = ∏ k ∈ range n, f k
state_after: no goals
tactic: (rw [mul_comm]; exact prod_range_mul_prod_Ico f h)
Theorem: String.length_replicate
File: Mathlib/Data/String/Lemmas.lean

Proof steps:
state_before: n : ℕ
c : Char
⊢ (replicate n c).length = n
state_after: no goals
tactic: simp only [String.length, String.replicate, List.length_replicate]
Theorem: CategoryTheory.IsPullback.zero_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ 0 ≫ 𝟙 X = 0 ≫ 0
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
s : Cone (cospan (𝟙 X) 0)
⊢ ∀ (j : WalkingCospan), (fun s => 0) s ≫ (PullbackCone.mk 0 0 ⋯).π.app j = s.π.app j
state_after: no goals
tactic: simpa [eq_iff_true_of_subsingleton] using
              @PullbackCone.equalizer_ext _ _ _ _ _ _ _ s _ 0 (𝟙 _)
                (by simpa using (PullbackCone.condition s).symm)
Theorem: Zsqrtd.intCast_dvd_intCast
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d a b : ℤ
⊢ ↑a ∣ ↑b ↔ a ∣ b
state_after: d a b : ℤ
⊢ a ∣ (↑b).re ∧ a ∣ (↑b).im ↔ a ∣ b
tactic: rw [intCast_dvd]
state_before: d a b : ℤ
⊢ a ∣ (↑b).re ∧ a ∣ (↑b).im ↔ a ∣ b
state_after: case mp
d a b : ℤ
⊢ a ∣ (↑b).re ∧ a ∣ (↑b).im → a ∣ b

case mpr
d a b : ℤ
⊢ a ∣ b → a ∣ (↑b).re ∧ a ∣ (↑b).im
tactic: constructor
Theorem: ENNReal.rpow_inv_le_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ^ 1 ↔ x ≤ y ^ z
tactic: nth_rw 1 [← ENNReal.rpow_one y]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ^ 1 ↔ x ≤ y ^ z
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ^ (z * z⁻¹) ↔ x ≤ y ^ z
tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z hz.ne.symm]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ^ (z * z⁻¹) ↔ x ≤ y ^ z
state_after: no goals
tactic: rw [ENNReal.rpow_mul, ENNReal.rpow_le_rpow_iff (inv_pos.2 hz)]
Theorem: AlgebraicTopology.DoldKan.P_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ P q ≫ P q = P q
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (P q ≫ P q).f n = (P q).f n
tactic: ext n
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (P q ≫ P q).f n = (P q).f n
state_after: no goals
tactic: exact P_f_idem q n
Theorem: abs_sub_lt_of_nonneg_of_lt
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_lt_n : a < n
b_nonneg : 0 ≤ b
b_lt_n : b < n
⊢ |a - b| < n
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_lt_n : a < n
b_nonneg : 0 ≤ b
b_lt_n : b < n
⊢ a < n + b ∧ b < n + a
tactic: rw [abs_sub_lt_iff, sub_lt_iff_lt_add, sub_lt_iff_lt_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_lt_n : a < n
b_nonneg : 0 ≤ b
b_lt_n : b < n
⊢ a < n + b ∧ b < n + a
state_after: no goals
tactic: exact ⟨lt_add_of_lt_of_nonneg a_lt_n b_nonneg, lt_add_of_lt_of_nonneg b_lt_n a_nonneg⟩
Theorem: Fin.eq_insertNth_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
p : Fin (n + 1)
a : α p
f : (i : Fin n) → α (p.succAbove i)
g : (j : Fin (n + 1)) → α j
⊢ g = p.insertNth a f ↔ g p = a ∧ p.removeNth g = f
state_after: no goals
tactic: simpa [eq_comm] using insertNth_eq_iff
Theorem: CategoryTheory.IsHomLift.eq_of_isHomLift
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
f : p.obj a ⟶ p.obj b
φ : a ⟶ b
inst✝ : p.IsHomLift f φ
⊢ f = p.map φ
state_after: no goals
tactic: simp only [fac p f φ, eqToHom_refl, comp_id, id_comp]
Theorem: IsAdjoinRoot.liftHom_root
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring S
f : R[X]
inst✝² : Algebra R S
T : Type u_1
inst✝¹ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
inst✝ : Algebra R T
hx' : (aeval x) f = 0
h : IsAdjoinRoot S f
⊢ (liftHom x hx' h) h.root = x
state_after: no goals
tactic: rw [← lift_algebraMap_apply, lift_root]
Theorem: differentiable_tsum'
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg : ∀ (n : α) (y : 𝕜), HasDerivAt (g n) (g' n y) y
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
⊢ Differentiable 𝕜 fun z => ∑' (n : α), g n z
state_after: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
hg : ∀ (n : α) (y : 𝕜), HasFDerivAt (g n) (ContinuousLinearMap.smulRight 1 (g' n y)) y
⊢ Differentiable 𝕜 fun z => ∑' (n : α), g n z
tactic: simp_rw [hasDerivAt_iff_hasFDerivAt] at hg
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
hg : ∀ (n : α) (y : 𝕜), HasFDerivAt (g n) (ContinuousLinearMap.smulRight 1 (g' n y)) y
⊢ Differentiable 𝕜 fun z => ∑' (n : α), g n z
state_after: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
hg : ∀ (n : α) (y : 𝕜), HasFDerivAt (g n) (ContinuousLinearMap.smulRight 1 (g' n y)) y
⊢ ∀ (n : α) (x : 𝕜), ‖ContinuousLinearMap.smulRight 1 (g' n x)‖ ≤ u n
tactic: refine differentiable_tsum hu hg ?_
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
hg : ∀ (n : α) (y : 𝕜), HasFDerivAt (g n) (ContinuousLinearMap.smulRight 1 (g' n y)) y
⊢ ∀ (n : α) (x : 𝕜), ‖ContinuousLinearMap.smulRight 1 (g' n x)‖ ≤ u n
state_after: no goals
tactic: simpa? says simpa only [ContinuousLinearMap.norm_smulRight_apply, norm_one, one_mul]
Theorem: Homeomorph.map_cocompact
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'
h : X ≃ₜ Y
⊢ map (⇑h) (cocompact X) = cocompact Y
state_after: no goals
tactic: rw [← h.comap_cocompact, map_comap_of_surjective h.surjective]
Theorem: CategoryTheory.ProjectiveResolution.ofComplex_d_1_0
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasProjectiveResolutions C
inst✝ : EnoughProjectives C
Z : C
⊢ (ofComplex Z).d 1 0 = d (Projective.π Z)
state_after: no goals
tactic: simp [ofComplex]