ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: StieltjesFunction.measure_Iic
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ f.measure (Iic x) = ofReal (↑f x - l)
state_after: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => f.measure (Ioc x_1 x)) atBot (𝓝 (ofReal (↑f x - l)))
tactic: refine tendsto_nhds_unique (tendsto_measure_Ioc_atBot _ _) ?_
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => f.measure (Ioc x_1 x)) atBot (𝓝 (ofReal (↑f x - l)))
state_after: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ofReal (↑f x - ↑f x_1)) atBot (𝓝 (ofReal (↑f x - l)))
tactic: simp_rw [measure_Ioc]
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ofReal (↑f x - ↑f x_1)) atBot (𝓝 (ofReal (↑f x - l)))
state_after: no goals
tactic: exact ENNReal.tendsto_ofReal (Tendsto.const_sub _ hf)
Theorem: StalkSkyscraperPresheafAdjunctionAuxs.counit_app
File: Mathlib/Topology/Sheaves/Skyscraper.lean

Proof steps:
state_before: X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
x y : C
f : x ⟶ y
U : (OpenNhds p₀)ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds p₀)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion p₀).op).obj
          ((skyscraperPresheafFunctor p₀).obj x))
        U ≫
      (skyscraperPresheafFunctor p₀ ⋙ Presheaf.stalkFunctor C p₀).map f ≫
        (fun c => (skyscraperPresheafStalkOfSpecializes p₀ c ⋯).hom) y =
    colimit.ι
        (((whiskeringLeft (OpenNhds p₀)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion p₀).op).obj
          ((skyscraperPresheafFunctor p₀).obj x))
        U ≫
      (fun c => (skyscraperPresheafStalkOfSpecializes p₀ c ⋯).hom) x ≫ (𝟭 C).map f
state_after: no goals
tactic: erw [← Category.assoc, colimit.ι_map, colimit.isoColimitCocone_ι_hom_assoc,
      skyscraperPresheafCoconeOfSpecializes_ι_app (h := specializes_rfl), Category.assoc,
      colimit.ι_desc, whiskeringLeft_obj_map, whiskerLeft_app, SkyscraperPresheafFunctor.map'_app,
      dif_pos U.unop.2, skyscraperPresheafCoconeOfSpecializes_ι_app (h := specializes_rfl),
      comp_eqToHom_iff, Category.assoc, eqToHom_comp_iff, ← Category.assoc, eqToHom_trans,
      eqToHom_refl, Category.id_comp, comp_eqToHom_iff, Category.assoc, eqToHom_trans, eqToHom_refl,
      Category.comp_id, CategoryTheory.Functor.id_map]
Theorem: ProbabilityTheory.Kernel.rnDerivAux_nonneg
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ η : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
hκη : κ ≤ η
a : α
x : γ
⊢ 0 ≤ κ.rnDerivAux η a x
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ η : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
hκη : κ ≤ η
a : α
x : γ
⊢ 0 ≤ if hα : Countable α then ((∂κ a/∂η a) x).toReal else (κ.map (fun a => (a, ())) ⋯).density η a x univ
tactic: rw [rnDerivAux]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ η : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
hκη : κ ≤ η
a : α
x : γ
⊢ 0 ≤ if hα : Countable α then ((∂κ a/∂η a) x).toReal else (κ.map (fun a => (a, ())) ⋯).density η a x univ
state_after: case pos
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ η : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
hκη : κ ≤ η
a : α
x : γ
hα : Countable α
⊢ 0 ≤ ((∂κ a/∂η a) x).toReal

case neg
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ η : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
hκη : κ ≤ η
a : α
x : γ
hα : ¬Countable α
⊢ 0 ≤ (κ.map (fun a => (a, ())) ⋯).density η a x univ
tactic: split_ifs with hα
Theorem: ContextFreeGrammar.reverse_derives
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
g : ContextFreeGrammar T
s : List (Symbol T g.NT)
hgs : g.reverse.Derives [Symbol.nonterminal g.reverse.initial] s
⊢ g.Derives [Symbol.nonterminal g.initial] s.reverse
state_after: no goals
tactic: induction hgs with
  | refl =>
    rw [List.reverse_singleton]
    apply ContextFreeGrammar.Derives.refl
  | tail _ orig ih =>
    apply ContextFreeGrammar.Derives.trans_produces ih
    obtain ⟨r, rin, rewr⟩ := orig
    simp only [ContextFreeGrammar.reverse, List.mem_map] at rin
    obtain ⟨r₀, rin₀, rfl⟩ := rin
    refine ⟨r₀, rin₀, ?_⟩
    rw [ContextFreeRule.rewrites_iff] at rewr ⊢
    rcases rewr with ⟨p, q, rfl, rfl⟩
    use q.reverse, p.reverse
    simp [ContextFreeRule.reverse]
Theorem: AntilipschitzWith.to_rightInvOn'
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
s : Set α
hf : AntilipschitzWith K (s.restrict f)
g : β → α
t : Set β
g_maps : MapsTo g t s
g_inv : RightInvOn g f t
x y : ↑t
⊢ edist (t.restrict g x) (t.restrict g y) ≤ ↑K * edist x y
state_after: no goals
tactic: simpa only [restrict_apply, g_inv x.mem, g_inv y.mem, Subtype.edist_eq, Subtype.coe_mk] using
    hf ⟨g x, g_maps x.mem⟩ ⟨g y, g_maps y.mem⟩
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_neg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ setToSimpleFunc T (map Neg.neg f) = -setToSimpleFunc T f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (-x) = ∑ x ∈ f.range, -(T (↑f ⁻¹' {x})) x
tactic: rw [map_setToSimpleFunc T h_add hf neg_zero, setToSimpleFunc, ← sum_neg_distrib]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (-x) = ∑ x ∈ f.range, -(T (↑f ⁻¹' {x})) x
state_after: no goals
tactic: exact Finset.sum_congr rfl fun x _ => ContinuousLinearMap.map_neg _ _
Theorem: cauchyPowerSeries_apply
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
w : ℂ
⊢ ((cauchyPowerSeries f c R n) fun x => w) = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (w / (z - c)) ^ n • (z - c)⁻¹ • f z
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
w : ℂ
⊢ (w ^ n • (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z) =
    (2 * ↑π * I)⁻¹ • w ^ n • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z
tactic: simp only [cauchyPowerSeries, ContinuousMultilinearMap.mkPiRing_apply, Fin.prod_const,
    div_eq_mul_inv, mul_pow, mul_smul, circleIntegral.integral_smul]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
w : ℂ
⊢ (w ^ n • (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z) =
    (2 * ↑π * I)⁻¹ • w ^ n • ∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z
state_after: no goals
tactic: rw [← smul_comm (w ^ n)]
Theorem: ZMod.eisenstein_lemma_aux
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (p % 2 = 1)
a : ℕ
ha2✝ : a % 2 = 1
hap : ↑a ≠ 0
ha2 : ↑a = ↑1
⊢ ↑(filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card - ↑(∑ x ∈ Ico 1 (p / 2).succ, x * a / p) = 0
state_after: no goals
tactic: simpa [add_left_comm, sub_eq_add_neg, ← mul_sum, mul_comm, ha2, Nat.cast_sum,
      add_neg_eq_iff_eq_add.symm, neg_eq_self_mod_two, add_assoc] using
      Eq.symm (eisenstein_lemma_aux₁ p hap)
Theorem: NonUnitalNonAssocSemiring.toDistrib_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toDistrib R)
state_after: R : Type u
a₁✝ a₂✝ : NonUnitalNonAssocSemiring R
h : toDistrib = toDistrib
⊢ a₁✝ = a₂✝
tactic: intro _ _ h
state_before: R : Type u
a₁✝ a₂✝ : NonUnitalNonAssocSemiring R
h : toDistrib = toDistrib
⊢ a₁✝ = a₂✝
state_after: case h_add.h.h
R : Type u
a₁✝ a₂✝ : NonUnitalNonAssocSemiring R
h : toDistrib = toDistrib
x y : R
⊢ x + y = x + y

case h_mul.h.h
R : Type u
a₁✝ a₂✝ : NonUnitalNonAssocSemiring R
h : toDistrib = toDistrib
x y : R
⊢ x * y = x * y
tactic: ext x y
Theorem: Finset.prod_dite_irrel
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 β
p : Prop
inst✝ : Decidable p
s : Finset α
f : p → α → β
g : ¬p → α → β
⊢ (∏ x ∈ s, if h : p then f h x else g h x) = if h : p then ∏ x ∈ s, f h x else ∏ x ∈ s, g h x
state_after: no goals
tactic: split_ifs with h <;> rfl
Theorem: Int.lt_or_le
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ b ≤ a
state_after: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ ¬a < b
tactic: rw [← Int.not_lt]
state_before: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ ¬a < b
state_after: no goals
tactic: exact em _
Theorem: Subgroup.fg_iff_add_fg
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_3
H : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ P.FG ↔ (toAddSubgroup P).FG
state_after: no goals
tactic: exact (Subgroup.toSubmonoid P).fg_iff_add_fg
Theorem: DFinsupp.support_tsub
File: Mathlib/Data/DFinsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → CanonicallyOrderedAddCommMonoid (α i)
inst✝³ : (i : ι) → Sub (α i)
inst✝² : ∀ (i : ι), OrderedSub (α i)
f g : Π₀ (i : ι), α i
i : ι
a b : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → (x : α i) → Decidable (x ≠ 0)
⊢ (f - g).support ⊆ f.support
state_after: no goals
tactic: simp (config := { contextual := true }) only [subset_iff, tsub_eq_zero_iff_le, mem_support_iff,
    Ne, coe_tsub, Pi.sub_apply, not_imp_not, zero_le, imp_true_iff]
Theorem: completeBipartiteGraph_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
v w : V ⊕ W
⊢ (fun v w => v.isLeft = true ∧ w.isRight = true ∨ v.isRight = true ∧ w.isLeft = true) v w →
    (fun v w => v.isLeft = true ∧ w.isRight = true ∨ v.isRight = true ∧ w.isLeft = true) w v
state_after: no goals
tactic: cases v <;> cases w <;> simp
state_before: V : Type u_1
W : Type u_2
v : V ⊕ W
⊢ ¬(fun v w => v.isLeft = true ∧ w.isRight = true ∨ v.isRight = true ∧ w.isLeft = true) v v
state_after: no goals
tactic: cases v <;> simp
Theorem: IsUnit.div_mul_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ a / b * b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, h.inv_mul_cancel_right]
Theorem: pi_Ioo_mem_nhds
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
⊢ Ioo a b ∈ 𝓝 x
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
i : ι
x✝ : i ∈ univ
⊢ Ioo (a i) (b i) ∈ 𝓝 (x i)
tactic: refine mem_of_superset (set_pi_mem_nhds Set.finite_univ fun i _ => ?_) (pi_univ_Ioo_subset a b)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
i : ι
x✝ : i ∈ univ
⊢ Ioo (a i) (b i) ∈ 𝓝 (x i)
state_after: no goals
tactic: exact Ioo_mem_nhds (ha i) (hb i)
Theorem: frontier_Icc
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 α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
a b : α
h : a ≤ b
⊢ frontier (Icc a b) = {a, b}
state_after: no goals
tactic: simp [frontier, h, Icc_diff_Ioo_same]
Theorem: lowerSemicontinuousOn_univ_iff
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f g : α → β
x : α
s t : Set α
y z : β
⊢ LowerSemicontinuousOn f univ ↔ LowerSemicontinuous f
state_after: no goals
tactic: simp [LowerSemicontinuousOn, LowerSemicontinuous, lowerSemicontinuousWithinAt_univ_iff]
Theorem: LSeriesSummable_lt_re_of_abscissaOfAbsConv_lt_re
File: Mathlib/NumberTheory/LSeries/Convergence.lean

Proof steps:
state_before: f : ℕ → ℂ
s : ℂ
hs : abscissaOfAbsConv f < ↑s.re
⊢ ∃ x < s.re, LSeriesSummable f ↑x
state_after: case intro.intro
f : ℕ → ℂ
s : ℂ
hs : abscissaOfAbsConv f < ↑s.re
x : ℝ
hx₁ : abscissaOfAbsConv f < ↑x
hx₂ : ↑x < ↑s.re
⊢ ∃ x < s.re, LSeriesSummable f ↑x
tactic: obtain ⟨x, hx₁, hx₂⟩ := EReal.exists_between_coe_real hs
state_before: case intro.intro
f : ℕ → ℂ
s : ℂ
hs : abscissaOfAbsConv f < ↑s.re
x : ℝ
hx₁ : abscissaOfAbsConv f < ↑x
hx₂ : ↑x < ↑s.re
⊢ ∃ x < s.re, LSeriesSummable f ↑x
state_after: no goals
tactic: exact ⟨x, EReal.coe_lt_coe_iff.mp hx₂, LSeriesSummable_of_abscissaOfAbsConv_lt_re hx₁⟩
Theorem: collinear_iff_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₀ : P
h : p₀ ∈ s
⊢ Collinear k s ↔ ∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₀ : P
h : p₀ ∈ s
⊢ (∃ v₀, ∀ v ∈ vectorSpan k s, ∃ r, r • v₀ = v) ↔ ∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀
tactic: simp_rw [collinear_iff_rank_le_one, rank_submodule_le_one_iff', Submodule.le_span_singleton_iff]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₀ : P
h : p₀ ∈ s
⊢ (∃ v₀, ∀ v ∈ vectorSpan k s, ∃ r, r • v₀ = v) ↔ ∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀
state_after: case mp
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₀ : P
h : p₀ ∈ s
⊢ (∃ v₀, ∀ v ∈ vectorSpan k s, ∃ r, r • v₀ = v) → ∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀

case mpr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₀ : P
h : p₀ ∈ s
⊢ (∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀) → ∃ v₀, ∀ v ∈ vectorSpan k s, ∃ r, r • v₀ = v
tactic: constructor
Theorem: HahnSeries.SummableFamily.embDomain_image
File: Mathlib/RingTheory/HahnSeries/Summable.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
β : Type u_4
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
⊢ (s.embDomain f) (f a) = s a
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
β : Type u_4
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
⊢ s (Classical.choose ⋯) = s a
tactic: rw [embDomain_apply, dif_pos (Set.mem_range_self a)]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
β : Type u_4
s : SummableFamily Γ R α
f : α ↪ β
a : α
b : β
⊢ s (Classical.choose ⋯) = s a
state_after: no goals
tactic: exact congr rfl (f.injective (Classical.choose_spec (Set.mem_range_self a)))
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_P_eq_self
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
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
⊢ φ ≫ (P q).f (n + 1) = φ
state_after: case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish 0 φ
⊢ φ ≫ (P 0).f (n + 1) = φ

case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n : ℕ
φ : Y ⟶ X _[n + 1]
q : ℕ
hq : HigherFacesVanish q φ → φ ≫ (P q).f (n + 1) = φ
v : HigherFacesVanish (q + 1) φ
⊢ φ ≫ (P (q + 1)).f (n + 1) = φ
tactic: induction' q with q hq
Theorem: schnirelmannDensity_le_iff_forall
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
x : ℝ
⊢ schnirelmannDensity A ≤ x ↔ ∀ (ε : ℝ), 0 < ε → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n < x + ε
state_after: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
x : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → schnirelmannDensity A < x + ε) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n < x + ε
tactic: rw [le_iff_forall_pos_lt_add]
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
x : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → schnirelmannDensity A < x + ε) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n < x + ε
state_after: no goals
tactic: simp only [schnirelmannDensity_lt_iff]
Theorem: Polynomial.Gal.restrictComp_surjective
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
⊢ Function.Surjective ⇑(restrictComp p q hq)
state_after: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
this : Fact (Splits (algebraMap F (p.comp q).SplittingField) p)
⊢ Function.Surjective ⇑(restrictComp p q hq)
tactic: haveI : Fact (Splits (algebraMap F (SplittingField (comp p q))) p) :=
    ⟨splits_in_splittingField_of_comp p q hq⟩
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
this : Fact (Splits (algebraMap F (p.comp q).SplittingField) p)
⊢ Function.Surjective ⇑(restrictComp p q hq)
state_after: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
this : Fact (Splits (algebraMap F (p.comp q).SplittingField) p)
⊢ Function.Surjective
    ⇑(let h := ⋯;
      restrict p (p.comp q).SplittingField)
tactic: rw [restrictComp]
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
this : Fact (Splits (algebraMap F (p.comp q).SplittingField) p)
⊢ Function.Surjective
    ⇑(let h := ⋯;
      restrict p (p.comp q).SplittingField)
state_after: no goals
tactic: exact restrict_surjective _ _
Theorem: tendstoUniformly_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F✝ : ι → α → β
f✝ : α → β
s s' : Set α
x : α
p✝ : Filter ι
p' : Filter α
g : ι → α
F : ι → α → β
f : α → β
p : Filter ι
⊢ TendstoUniformly F f p ↔ Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ ⊤) (𝓤 β)
state_after: no goals
tactic: simp [tendstoUniformly_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto]
Theorem: continuous_induced_rng
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
g : γ → α
t₂ : TopologicalSpace β
t₁ : TopologicalSpace γ
⊢ Continuous g ↔ Continuous (f ∘ g)
state_after: no goals
tactic: simp only [continuous_iff_le_induced, induced_compose]
Theorem: SimpleGraph.walkLengthTwoEquivCommonNeighbors_apply_coe
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v v✝ : V
h✝¹ : G.Adj u v✝
h✝ : G.Adj v✝ v
hp : (Walk.cons h✝¹ (Walk.cons h✝ Walk.nil)).length = 2
⊢ (fun w => ⟨(Adj.toWalk ⋯).concat ⋯, ⋯⟩) ((fun p => ⟨(↑p).getVert 1, ⋯⟩) ⟨Walk.cons h✝¹ (Walk.cons h✝ Walk.nil), hp⟩) =
    ⟨Walk.cons h✝¹ (Walk.cons h✝ Walk.nil), hp⟩
state_after: no goals
tactic: rfl
Theorem: CochainComplex.HomComplex.Cochain.shift_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
p' q' : ℤ
hp' : p' = p + a
hq' : q' = q + a
⊢ p' + n = q'
state_after: no goals
tactic: rw [hp', hq', ← hpq, add_assoc, add_comm a, add_assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
p' q' : ℤ
hp' : p' = p + a
hq' : q' = q + a
⊢ (γ.shift a).v p q hpq = (K.shiftFunctorObjXIso a p p' hp').hom ≫ γ.v p' q' ⋯ ≫ (L.shiftFunctorObjXIso a q q' hq').inv
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ (γ.shift a).v p q hpq =
    (K.shiftFunctorObjXIso a p (p + a) ⋯).hom ≫ γ.v (p + a) (q + a) ⋯ ≫ (L.shiftFunctorObjXIso a q (q + a) ⋯).inv
tactic: subst hp' hq'
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ (γ.shift a).v p q hpq =
    (K.shiftFunctorObjXIso a p (p + a) ⋯).hom ≫ γ.v (p + a) (q + a) ⋯ ≫ (L.shiftFunctorObjXIso a q (q + a) ⋯).inv
state_after: no goals
tactic: rfl