ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.integral_indicatorConstLp
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace X
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
inst✝ : CompleteSpace E
p : ℝ≥0∞
ht : MeasurableSet t
hμt : μ t ≠ ⊤
e : E
⊢ ∫ (x : X), ↑↑(indicatorConstLp p ht hμt e) x ∂μ = ∫ (x : X) in univ, ↑↑(indicatorConstLp p ht hμt e) x ∂μ
state_after: no goals
tactic: rw [integral_univ]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace X
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
inst✝ : CompleteSpace E
p : ℝ≥0∞
ht : MeasurableSet t
hμt : μ t ≠ ⊤
e : E
⊢ (μ (t ∩ univ)).toReal • e = (μ t).toReal • e
state_after: no goals
tactic: rw [inter_univ]
Theorem: Filter.nhds_pure
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
x : α
⊢ 𝓝 (pure x) = 𝓟 {⊥, pure x}
state_after: no goals
tactic: rw [← principal_singleton, nhds_principal, principal_singleton, Iic_pure]
Theorem: Finset.sum_update_of_not_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
⊢ ∏ x ∈ s, update f i b x = ∏ x ∈ s, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
⊢ ∀ x ∈ s, update f i b x = f x
tactic: apply prod_congr rfl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
⊢ ∀ x ∈ s, update f i b x = f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
j : α
hj : j ∈ s
⊢ update f i b j = f j
tactic: intros j hj
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
j : α
hj : j ∈ s
⊢ update f i b j = f j
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
j : α
hj : j ∈ s
this : j ≠ i
⊢ update f i b j = f j
tactic: have : j ≠ i := by
    rintro rfl
    exact h hj
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∉ s
f : α → β
b : β
j : α
hj : j ∈ s
this : j ≠ i
⊢ update f i b j = f j
state_after: no goals
tactic: simp [this]
Theorem: Prod.map_iterate
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → α
g : β → β
n : ℕ
⊢ (map f g)^[n] = map f^[n] g^[n]
state_after: no goals
tactic: induction n <;> simp [*, Prod.map_comp_map]
Theorem: Filter.inf_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s ⊓ 𝓟 t ≤ 𝓟 (s ∩ t)
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ ∃ t₁ ∈ 𝓟 s, ∃ t₂ ∈ 𝓟 t, s ∩ t = t₁ ∩ t₂
tactic: simp only [le_principal_iff, mem_inf_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ ∃ t₁ ∈ 𝓟 s, ∃ t₂ ∈ 𝓟 t, s ∩ t = t₁ ∩ t₂
state_after: no goals
tactic: exact ⟨s, Subset.rfl, t, Subset.rfl, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 (s ∩ t) ≤ 𝓟 s ⊓ 𝓟 t
state_after: no goals
tactic: simp [le_inf_iff, inter_subset_left, inter_subset_right]
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ snd (fst f g) (fst f g) ≫ fst f g = snd (snd g g ≫ g) f
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      snd (fst f g) (fst f g) ≫ fst f g =
    snd (snd g g ≫ g) f
tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      snd (fst f g) (fst f g) ≫ fst f g =
    snd (snd g g ≫ g) f
state_after: no goals
tactic: simp
Theorem: subset_interior_iff_mem_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ s ⊆ interior t ↔ t ∈ 𝓝ˢ s
state_after: no goals
tactic: simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
Theorem: Metric.lipschitz_infDist
File: Mathlib/Topology/MetricSpace/Closeds.lean

Proof steps:
state_before: α : Type u
inst✝ : MetricSpace α
⊢ LipschitzWith 2 fun p => infDist p.1 ↑p.2
state_after: case h.e'_5
α : Type u
inst✝ : MetricSpace α
⊢ 2 = 1 + 1
tactic: convert @LipschitzWith.uncurry α (NonemptyCompacts α) ℝ _ _ _
    (fun (x : α) (s : NonemptyCompacts α) => infDist x s) 1 1
    (fun s => lipschitz_infDist_pt ↑s) lipschitz_infDist_set
state_before: case h.e'_5
α : Type u
inst✝ : MetricSpace α
⊢ 2 = 1 + 1
state_after: no goals
tactic: norm_num
Theorem: fkg
File: Mathlib/Combinatorics/SetFamily/FourFunctions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
⊢ (∑ a : α, μ a * f a) * ∑ a : α, μ a * g a ≤ (∑ a : α, μ a) * ∑ a : α, μ a * (f a * g a)
state_after: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ (μ * f) a * (μ * g) b ≤ μ (a ⊓ b) * (μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b)))
tactic: refine four_functions_theorem_univ (μ * f) (μ * g) μ _ (mul_nonneg hμ₀ hf₀) (mul_nonneg hμ₀ hg₀)
    hμ₀ (mul_nonneg hμ₀ <| mul_nonneg hf₀ hg₀) (fun a b ↦ ?_)
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ (μ * f) a * (μ * g) b ≤ μ (a ⊓ b) * (μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b)))
state_after: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ μ a * f a * (μ b * g b) ≤ μ (a ⊓ b) * (μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b)))
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ μ a * f a * (μ b * g b) ≤ μ (a ⊓ b) * (μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b)))
state_after: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ μ a * μ b * (f a * g b) ≤ μ (a ⊓ b) * μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b))
tactic: rw [mul_mul_mul_comm, ← mul_assoc (μ (a ⊓ b))]
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
hμ₀ : 0 ≤ μ
hf₀ : 0 ≤ f
hg₀ : 0 ≤ g
hf : Monotone f
hg : Monotone g
hμ : ∀ (a b : α), μ a * μ b ≤ μ (a ⊓ b) * μ (a ⊔ b)
a b : α
⊢ μ a * μ b * (f a * g b) ≤ μ (a ⊓ b) * μ (a ⊔ b) * (f (a ⊔ b) * g (a ⊔ b))
state_after: no goals
tactic: exact mul_le_mul (hμ _ _) (mul_le_mul (hf le_sup_left) (hg le_sup_right) (hg₀ _) <| hf₀ _)
    (mul_nonneg (hf₀ _) <| hg₀ _) <| mul_nonneg (hμ₀ _) <| hμ₀ _
Theorem: Finset.prod_fiberwise_eq_prod_filter'
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝¹ s₁ s₂ : Finset α✝
a : α✝
f✝¹ g✝¹ : α✝ → β
inst✝² : CommMonoid β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝¹ : CommMonoid α
s✝ : Finset ι
t✝ : Finset κ
f✝ : ι → α
g✝ : κ → α
inst✝ : DecidableEq κ
s : Finset ι
t : Finset κ
g : ι → κ
f : κ → α
⊢ ∏ j ∈ t, ∏ _i ∈ filter (fun i => g i = j) s, f j = ∏ i ∈ filter (fun i => g i ∈ t) s, f (g i)
state_after: no goals
tactic: calc
    _ = ∏ j ∈ t, ∏ i ∈ s.filter fun i ↦ g i = j, f (g i) :=
        prod_congr rfl fun j _ ↦ prod_congr rfl fun i hi ↦ by rw [(mem_filter.1 hi).2]
    _ = _ := prod_fiberwise_eq_prod_filter _ _ _ _
Theorem: ZetaAsymptotics.term_welldef
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

Proof steps:
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntervalIntegrable (fun x => (x - ↑n) / x ^ (s + 1)) volume (↑n) (↑n + 1)
state_after: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntegrableOn (fun x => (x - ↑n) / x ^ (s + 1)) (Icc (↑n) (↑n + 1)) volume
tactic: rw [intervalIntegrable_iff_integrableOn_Icc_of_le (by linarith)]
state_before: n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
⊢ IntegrableOn (fun x => (x - ↑n) / x ^ (s + 1)) (Icc (↑n) (↑n + 1)) volume
state_after: case refine_1
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x - ↑n) x

case refine_2
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ ContinuousAt (fun x => x ^ (s + 1)) x

case refine_3
n : ℕ
hn : 0 < n
s : ℝ
hs : 0 < s
x : ℝ
hx : x ∈ Icc (↑n) (↑n + 1)
⊢ x ^ (s + 1) ≠ 0
tactic: refine (ContinuousAt.continuousOn fun x hx ↦ ContinuousAt.div ?_ ?_ ?_).integrableOn_Icc
Theorem: List.sum_add_sum_eq_sum_zipWith_of_length_eq
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l✝ l₁ l₂ l l' : List M
h : l.length = l'.length
⊢ l.prod * l'.prod = (zipWith (fun x x_1 => x * x_1) l l').prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l✝ l₁ l₂ l l' : List M
h : l.length = l'.length
⊢ (zipWith (fun x x_1 => x * x_1) l l').prod * (drop l'.length l).prod * (drop l.length l').prod =
    (zipWith (fun x x_1 => x * x_1) l l').prod
tactic: apply (prod_mul_prod_eq_prod_zipWith_mul_prod_drop l l').trans
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l✝ l₁ l₂ l l' : List M
h : l.length = l'.length
⊢ (zipWith (fun x x_1 => x * x_1) l l').prod * (drop l'.length l).prod * (drop l.length l').prod =
    (zipWith (fun x x_1 => x * x_1) l l').prod
state_after: no goals
tactic: rw [← h, drop_length, h, drop_length, prod_nil, mul_one, mul_one]
Theorem: TopCat.isSheaf_of_isLimit
File: Mathlib/Topology/Sheaves/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), (F.obj j).IsSheaf
c : Cone F
hc : IsLimit c
⊢ c.pt.IsSheaf
state_after: C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), (F.obj j).IsSheaf
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  { obj := fun j => { val := F.obj j, cond := ⋯ }, map := fun {X_1 Y} f => { val := F.map f }, map_id := ⋯,
    map_comp := ⋯ }
⊢ c.pt.IsSheaf
tactic: let F' : J ⥤ Sheaf C X :=
    { obj := fun j => ⟨F.obj j, H j⟩
      map := fun f => ⟨F.map f⟩ }
state_before: C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), (F.obj j).IsSheaf
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  { obj := fun j => { val := F.obj j, cond := ⋯ }, map := fun {X_1 Y} f => { val := F.map f }, map_id := ⋯,
    map_comp := ⋯ }
⊢ c.pt.IsSheaf
state_after: C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), (F.obj j).IsSheaf
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  { obj := fun j => { val := F.obj j, cond := ⋯ }, map := fun {X_1 Y} f => { val := F.map f }, map_id := ⋯,
    map_comp := ⋯ }
e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents (fun x => Iso.refl ((F' ⋙ Sheaf.forget C X).obj x)) ⋯
⊢ c.pt.IsSheaf
tactic: let e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents fun _ => Iso.refl _
state_before: C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimits C
X : TopCat
F : J ⥤ Presheaf C X
H : ∀ (j : J), (F.obj j).IsSheaf
c : Cone F
hc : IsLimit c
F' : J ⥤ Sheaf C X :=
  { obj := fun j => { val := F.obj j, cond := ⋯ }, map := fun {X_1 Y} f => { val := F.map f }, map_id := ⋯,
    map_comp := ⋯ }
e : F' ⋙ Sheaf.forget C X ≅ F := NatIso.ofComponents (fun x => Iso.refl ((F' ⋙ Sheaf.forget C X).obj x)) ⋯
⊢ c.pt.IsSheaf
state_after: no goals
tactic: exact Presheaf.isSheaf_of_iso
    ((isLimitOfPreserves (Sheaf.forget C X) (limit.isLimit F')).conePointsIsoOfNatIso hc e)
    (limit F').2
Theorem: _private.Mathlib.NumberTheory.Padics.Hensel.0.T_lt_one
File: Mathlib/NumberTheory/Padics/Hensel.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ T_gen p F a < 1
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
⊢ T_gen p F a < 1
tactic: have h := (div_lt_one (deriv_sq_norm_pos hnorm)).2 hnorm
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
⊢ T_gen p F a < 1
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
⊢ ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
tactic: rw [T_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
⊢ ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 < 1
state_after: no goals
tactic: exact h
Theorem: Submodule.mem_mul_span_singleton
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x y : A
⊢ x ∈ map ((LinearMap.mul R A).flip y) P ↔ ∃ z ∈ P, Mul.mul z y = x
state_after: no goals
tactic: rfl
Theorem: Matrix.blockDiagonal_one
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝⁴ : DecidableEq o
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq m
inst✝ : One α
⊢ (blockDiagonal fun x => diagonal fun x => 1) = diagonal fun x => 1
state_after: no goals
tactic: rw [blockDiagonal_diagonal]
Theorem: EMetric.mem_ball_self
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 α
h : 0 < ε
⊢ x ∈ ball x ε
state_after: no goals
tactic: rwa [mem_ball, edist_self]
Theorem: AddSubgroup.exists_right_transversal_of_le
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
⊢ ∃ S, ↑H' * S = ↑H ∧ Nat.card ↥H' * Nat.card ↑S = Nat.card ↥H
state_after: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
⊢ ∃ S, ↑H' * S = ↑H ∧ Nat.card ↥H' * Nat.card ↑S = Nat.card ↥H
tactic: let H'' : Subgroup H := H'.comap H.subtype
state_before: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
⊢ ∃ S, ↑H' * S = ↑H ∧ Nat.card ↥H' * Nat.card ↑S = Nat.card ↥H
state_after: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
⊢ ∃ S, ↑H' * S = ↑H ∧ Nat.card ↥H' * Nat.card ↑S = Nat.card ↥H
tactic: have : H' = H''.map H.subtype := by simp [H'', h]
state_before: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
⊢ ∃ S, ↑H' * S = ↑H ∧ Nat.card ↥H' * Nat.card ↑S = Nat.card ↥H
state_after: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
⊢ ∃ S, ↑(map H.subtype H'') * S = ↑H ∧ Nat.card ↥(map H.subtype H'') * Nat.card ↑S = Nat.card ↥H
tactic: rw [this]
state_before: G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
⊢ ∃ S, ↑(map H.subtype H'') * S = ↑H ∧ Nat.card ↥(map H.subtype H'') * Nat.card ↑S = Nat.card ↥H
state_after: case intro.intro
G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S✝ T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
S : Set ↥H
cmem : S ∈ rightTransversals ↑H''
⊢ ∃ S, ↑(map H.subtype H'') * S = ↑H ∧ Nat.card ↥(map H.subtype H'') * Nat.card ↑S = Nat.card ↥H
tactic: obtain ⟨S, cmem, -⟩ := H''.exists_right_transversal 1
state_before: case intro.intro
G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S✝ T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
S : Set ↥H
cmem : S ∈ rightTransversals ↑H''
⊢ ∃ S, ↑(map H.subtype H'') * S = ↑H ∧ Nat.card ↥(map H.subtype H'') * Nat.card ↑S = Nat.card ↥H
state_after: case intro.intro.refine_1
G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S✝ T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
S : Set ↥H
cmem : S ∈ rightTransversals ↑H''
⊢ ↑(map H.subtype H'') * ⇑H.subtype '' S = ↑H

case intro.intro.refine_2
G : Type u_1
inst✝ : Group G
H✝ K : Subgroup G
S✝ T : Set G
H' H : Subgroup G
h : H' ≤ H
H'' : Subgroup ↥H := comap H.subtype H'
this : H' = map H.subtype H''
S : Set ↥H
cmem : S ∈ rightTransversals ↑H''
⊢ Nat.card ↥(map H.subtype H'') * Nat.card ↑(⇑H.subtype '' S) = Nat.card ↥H
tactic: refine ⟨H.subtype '' S, ?_, ?_⟩
Theorem: KaehlerDifferential.one_smul_sub_smul_one_mem_ideal
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
a : S
⊢ 1 ⊗ₜ[R] a - a ⊗ₜ[R] 1 ∈ ideal R S
state_after: no goals
tactic: simp [RingHom.mem_ker]
Theorem: GenContFract.exists_rat_eq_nth_conv
File: Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ ∃ q, (of v).convs n = ↑q
state_after: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
⊢ ∃ q, (of v).convs n = ↑q
tactic: rcases exists_rat_eq_nth_num v n with ⟨Aₙ, nth_num_eq⟩
state_before: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
⊢ ∃ q, (of v).convs n = ↑q
state_after: case intro.intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
Bₙ : ℚ
nth_den_eq : (of v).dens n = ↑Bₙ
⊢ ∃ q, (of v).convs n = ↑q
tactic: rcases exists_rat_eq_nth_den v n with ⟨Bₙ, nth_den_eq⟩
state_before: case intro.intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
Bₙ : ℚ
nth_den_eq : (of v).dens n = ↑Bₙ
⊢ ∃ q, (of v).convs n = ↑q
state_after: case h
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
Bₙ : ℚ
nth_den_eq : (of v).dens n = ↑Bₙ
⊢ (of v).convs n = ↑(Aₙ / Bₙ)
tactic: use Aₙ / Bₙ
state_before: case h
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
Aₙ : ℚ
nth_num_eq : (of v).nums n = ↑Aₙ
Bₙ : ℚ
nth_den_eq : (of v).dens n = ↑Bₙ
⊢ (of v).convs n = ↑(Aₙ / Bₙ)
state_after: no goals
tactic: simp [nth_num_eq, nth_den_eq, conv_eq_num_div_den]