ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: GradedMonoid.list_prod_ofFn_eq_dProd
File: Mathlib/Algebra/GradedMonoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
n : ℕ
f : Fin n → GradedMonoid A
⊢ (List.ofFn f).prod =
    mk ((List.finRange n).dProdIndex fun i => (f i).fst)
      ((List.finRange n).dProd (fun i => (f i).fst) fun i => (f i).snd)
state_after: no goals
tactic: rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd]
Theorem: Basis.ofVectorSpace_apply_self
File: Mathlib/LinearAlgebra/Basis/VectorSpace.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
K : Type u_3
V : Type u_4
V' : Type u_5
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y z : V
x : ↑(ofVectorSpaceIndex K V)
⊢ (ofVectorSpace K V) x = ↑x
state_after: ι : Type u_1
ι' : Type u_2
K : Type u_3
V : Type u_4
V' : Type u_5
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y z : V
x : ↑(ofVectorSpaceIndex K V)
⊢ (extend ⋯) x = ↑x
tactic: unfold ofVectorSpace
state_before: ι : Type u_1
ι' : Type u_2
K : Type u_3
V : Type u_4
V' : Type u_5
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y z : V
x : ↑(ofVectorSpaceIndex K V)
⊢ (extend ⋯) x = ↑x
state_after: no goals
tactic: exact Basis.mk_apply _ _ _
Theorem: nhdsWithin_inter_of_mem
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : s ∈ 𝓝[t] a
⊢ 𝓝[s ∩ t] a = 𝓝[t] a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : s ∈ 𝓝[t] a
⊢ 𝓝[t] a ≤ 𝓝[s] a
tactic: rw [nhdsWithin_inter, inf_eq_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : s ∈ 𝓝[t] a
⊢ 𝓝[t] a ≤ 𝓝[s] a
state_after: no goals
tactic: exact nhdsWithin_le_of_mem h
Theorem: cfc_comp_neg
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommRing R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalRing R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
hf✝ : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝ : UniqueContinuousFunctionalCalculus R A
hf : autoParam (ContinuousOn f ((fun x => -x) '' spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f (-x)) a = cfc f (-a)
state_after: no goals
tactic: rw [cfc_comp' .., cfc_neg_id _]
Theorem: integrableOn_Iic_iff_integrableOn_Iio
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ μ {b} ≠ ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
state_after: no goals
tactic: exact ENNReal.zero_ne_top
Theorem: Filter.frequently_cofinite_iff_infinite
File: Mathlib/Order/Filter/Cofinite.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
p : α → Prop
⊢ (∃ᶠ (x : α) in cofinite, p x) ↔ {x | p x}.Infinite
state_after: no goals
tactic: simp only [Filter.Frequently, eventually_cofinite, not_not, Set.Infinite]
Theorem: WeierstrassCurve.Jacobian.Point.toAffineLift_add
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 : W.Point
⊢ (P + Q).toAffineLift = P.toAffineLift + Q.toAffineLift
state_after: case mk.mk.mk.mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
point✝¹ : PointClass F
a✝¹ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝¹)
point✝ : PointClass F
a✝ : Fin 3 → F
hQ : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ (mk hP + mk hQ).toAffineLift = (mk hP).toAffineLift + (mk hQ).toAffineLift
tactic: rcases P, Q with ⟨@⟨⟨_⟩, hP⟩, @⟨⟨_⟩, hQ⟩⟩
state_before: case mk.mk.mk.mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
point✝¹ : PointClass F
a✝¹ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝¹)
point✝ : PointClass F
a✝ : Fin 3 → F
hQ : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ (mk hP + mk hQ).toAffineLift = (mk hP).toAffineLift + (mk hQ).toAffineLift
state_after: no goals
tactic: exact toAffine_add hP hQ
Theorem: tendsto_neg_nhdsWithin_Iic_neg
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto Inv.inv (𝓝[≤] a⁻¹) (𝓝[≥] a)
state_after: no goals
tactic: simpa only [inv_inv] using @tendsto_inv_nhdsWithin_Iic _ _ _ _ a⁻¹
Theorem: Complex.stolzSet_empty
File: Mathlib/Analysis/Complex/AbelLimit.lean

Proof steps:
state_before: M : ℝ
hM : M ≤ 1
⊢ stolzSet M = ∅
state_after: case h
M : ℝ
hM : M ≤ 1
z : ℂ
⊢ z ∈ stolzSet M ↔ z ∈ ∅
tactic: ext z
state_before: case h
M : ℝ
hM : M ≤ 1
z : ℂ
⊢ z ∈ stolzSet M ↔ z ∈ ∅
state_after: case h
M : ℝ
hM : M ≤ 1
z : ℂ
⊢ 0 < 1 - ‖z‖ → M * (1 - ‖z‖) ≤ ‖1 - z‖
tactic: rw [stolzSet, Set.mem_setOf, Set.mem_empty_iff_false, iff_false, not_and, not_lt, ← sub_pos]
state_before: case h
M : ℝ
hM : M ≤ 1
z : ℂ
⊢ 0 < 1 - ‖z‖ → M * (1 - ‖z‖) ≤ ‖1 - z‖
state_after: case h
M : ℝ
hM : M ≤ 1
z : ℂ
zn : 0 < 1 - ‖z‖
⊢ M * (1 - ‖z‖) ≤ ‖1 - z‖
tactic: intro zn
state_before: case h
M : ℝ
hM : M ≤ 1
z : ℂ
zn : 0 < 1 - ‖z‖
⊢ M * (1 - ‖z‖) ≤ ‖1 - z‖
state_after: no goals
tactic: calc
    _ ≤ 1 * (1 - ‖z‖) := mul_le_mul_of_nonneg_right hM zn.le
    _ = ‖(1 : ℂ)‖ - ‖z‖ := by rw [one_mul, norm_one]
    _ ≤ _ := norm_sub_norm_le _ _
Theorem: Filter.EventuallyConst.indicator_const_iff
File: Mathlib/Order/Filter/EventuallyConst.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f : α → β
inst✝ : One β
s : Set α
c : β
⊢ EventuallyConst (s.mulIndicator fun x => c) l ↔ c = 1 ∨ EventuallyConst s l
state_after: no goals
tactic: rcases eq_or_ne c 1 with rfl | hc <;> simp [mulIndicator_const_iff_of_ne, *]
Theorem: List.sizeOf_kerase
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
xs : List (Sigma β)
⊢ sizeOf (kerase x xs) ≤ sizeOf xs
state_after: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
xs : List (Sigma β)
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x xs) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) xs
tactic: simp only [SizeOf.sizeOf, _sizeOf_1]
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
xs : List (Sigma β)
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x xs) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) xs
state_after: case nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x []) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) []

case cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝¹ : DecidableEq α
inst✝ : SizeOf (Sigma β)
x : α
y : Sigma β
ys : List (Sigma β)
tail_ih✝ :
  rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x ys) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) ys
⊢ rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (kerase x (y :: ys)) ≤
    rec 1 (fun head tail tail_ih => 1 + sizeOf head + tail_ih) (y :: ys)
tactic: induction' xs with y ys
Theorem: TwoSidedIdeal.add_mem
File: Mathlib/RingTheory/TwoSidedIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : NonUnitalNonAssocRing R
I : TwoSidedIdeal R
x y : R
hx : x ∈ I
hy : y ∈ I
⊢ x + y ∈ I
state_after: no goals
tactic: simpa using I.ringCon.add hx hy
Theorem: List.rotate_eq_nil_iff
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate n = [] ↔ l = []
state_after: case zero
α : Type u
l : List α
⊢ l.rotate 0 = [] ↔ l = []

case succ
α : Type u
n : ℕ
hn : ∀ {l : List α}, l.rotate n = [] ↔ l = []
l : List α
⊢ l.rotate (n + 1) = [] ↔ l = []
tactic: induction' n with n hn generalizing l
Theorem: HasCompactSupport.mul_left
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : HasCompactSupport f'
⊢ HasCompactSupport (f * f')
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f' =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0
tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝¹ : TopologicalSpace α
inst✝ : MulZeroClass β
f f' : α → β
x : α
hf : f' =ᶠ[coclosedCompact α] 0
⊢ f * f' =ᶠ[coclosedCompact α] 0
state_after: no goals
tactic: exact hf.mono fun x hx => by simp_rw [Pi.mul_apply, hx, Pi.zero_apply, mul_zero]
Theorem: Complex.arg_inv
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ x⁻¹.arg = if x.arg = π then π else -x.arg
state_after: a x✝ z x : ℂ
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
tactic: rw [← arg_conj, inv_def, mul_comm]
state_before: a x✝ z x : ℂ
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
state_after: case pos
a x✝ z x : ℂ
hx : x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg

case neg
a x✝ z x : ℂ
hx : ¬x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
tactic: by_cases hx : x = 0
Theorem: AddCommGroup.ModEq.of_nsmul
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a ≡ b [PMOD n • p]
m : ℤ
hm : b - a = m • n • p
⊢ b - a = (m * ↑n) • p
state_after: no goals
tactic: rwa [mul_smul, natCast_zsmul]
Theorem: Part.fix_def'
File: Mathlib/Control/Fix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ Part.fix f x = none
state_after: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = none
tactic: dsimp [Part.fix]
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = none
state_after: no goals
tactic: rw [assert_neg h']
Theorem: FormalMultilinearSeries.compPartialSumTarget_tendsto_atTop
File: Mathlib/Analysis/Analytic/Composition.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
⊢ Tendsto (fun N => compPartialSumTarget 0 N N) atTop atTop
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
⊢ Monotone fun N => compPartialSumTarget 0 N N

case h'
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
⊢ ∀ (x : (n : ℕ) × Composition n), ∃ n, x ∈ compPartialSumTarget 0 n n
tactic: apply Monotone.tendsto_atTop_finset
Theorem: contDiffAt_top
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiffAt 𝕜 ⊤ f x ↔ ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) f x
state_after: no goals
tactic: simp [← contDiffWithinAt_univ, contDiffWithinAt_top]
Theorem: MeasureTheory.Measure.isMulInvariant_eq_smul_of_compactSpace
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
⊢ μ' = μ'.haarScalarFactor μ • μ
state_after: case h
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
s : Set G
_hs : MeasurableSet s
⊢ μ' s = (μ'.haarScalarFactor μ • μ) s
tactic: ext s _hs
state_before: case h
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
s : Set G
_hs : MeasurableSet s
⊢ μ' s = (μ'.haarScalarFactor μ • μ) s
state_after: no goals
tactic: exact measure_isMulInvariant_eq_smul_of_isCompact_closure _ _ isClosed_closure.isCompact
Theorem: MeasureTheory.measure_vadd_eq_zero_iff
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
c : G
⊢ μ (c • s) = 0 ↔ μ s = 0
state_after: no goals
tactic: rw [measure_smul]
Theorem: TopologicalSpace.nhds_generateFrom
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
g : Set (Set α)
a : α
⊢ 𝓝 a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
state_after: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ 𝓝 a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
tactic: letI := generateFrom g
state_before: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ 𝓝 a = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
state_after: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ ⨅ s ∈ {s | a ∈ s ∧ IsOpen s}, 𝓟 s = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
tactic: rw [nhds_def]
state_before: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ ⨅ s ∈ {s | a ∈ s ∧ IsOpen s}, 𝓟 s = ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s
state_after: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ ∀ i ∈ {s | a ∈ s ∧ IsOpen s}, ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 i
tactic: refine le_antisymm (biInf_mono fun s ⟨as, sg⟩ => ⟨as, .basic _ sg⟩) <| le_iInf₂ ?_
state_before: α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
⊢ ∀ i ∈ {s | a ∈ s ∧ IsOpen s}, ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 i
state_after: case intro
α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
s : Set α
ha : a ∈ s
hs : IsOpen s
⊢ ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 s
tactic: rintro s ⟨ha, hs⟩
state_before: case intro
α : Type u
g : Set (Set α)
a : α
this : TopologicalSpace α := generateFrom g
s : Set α
ha : a ∈ s
hs : IsOpen s
⊢ ⨅ s ∈ {s | a ∈ s ∧ s ∈ g}, 𝓟 s ≤ 𝓟 s
state_after: no goals
tactic: induction hs with
  | basic _ hs => exact iInf₂_le _ ⟨ha, hs⟩
  | univ => exact le_top.trans_eq principal_univ.symm
  | inter _ _ _ _ hs ht => exact (le_inf (hs ha.1) (ht ha.2)).trans_eq inf_principal
  | sUnion _ _ hS =>
    let ⟨t, htS, hat⟩ := ha
    exact (hS t htS hat).trans (principal_mono.2 <| subset_sUnion_of_mem htS)
Theorem: Nat.choose_pos
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: x✝ : ℕ
hk : x✝ ≤ 0
⊢ 0 < choose 0 x✝
state_after: x✝ : ℕ
hk : x✝ ≤ 0
⊢ 0 < choose 0 0
tactic: rw [Nat.eq_zero_of_le_zero hk]
state_before: x✝ : ℕ
hk : x✝ ≤ 0
⊢ 0 < choose 0 0
state_after: no goals
tactic: decide
state_before: n : ℕ
x✝ : 0 ≤ n + 1
⊢ 0 < (n + 1).choose 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.OplaxNatTrans.ModificationIso.ofComponents_hom_app
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
app : (a : B) → η.app a ≅ θ.app a
naturality : ∀ {a b : B} (f : a ⟶ b), F.map f ◁ (app b).hom ≫ θ.naturality f = η.naturality f ≫ (app a).hom ▷ G.map f
a b : B
f : a ⟶ b
⊢ F.map f ◁ (fun a => (app a).inv) b ≫ η.naturality f = θ.naturality f ≫ (fun a => (app a).inv) a ▷ G.map f
state_after: no goals
tactic: simpa using congr_arg (fun f => _ ◁ (app b).inv ≫ f ≫ (app a).inv ▷ _) (naturality f).symm
Theorem: Set.Countable.image
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : s.Countable
f : α → β
⊢ (f '' s).Countable
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : s.Countable
f : α → β
⊢ (range fun x => f ↑x).Countable
tactic: rw [image_eq_range]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : s.Countable
f : α → β
⊢ (range fun x => f ↑x).Countable
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : s.Countable
f : α → β
this : Countable ↑s
⊢ (range fun x => f ↑x).Countable
tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : s.Countable
f : α → β
this : Countable ↑s
⊢ (range fun x => f ↑x).Countable
state_after: no goals
tactic: apply countable_range
Theorem: map_natCast_smul
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R✝ : Type u_2
k : Type u_3
S✝ : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
F : Type u_9
inst✝⁵ : FunLike F M M₂
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_10
S : Type u_11
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : ℕ
a : M
⊢ f (↑x • a) = ↑x • f a
state_after: no goals
tactic: simp only [Nat.cast_smul_eq_nsmul, AddMonoidHom.map_nsmul, map_nsmul]
Theorem: CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.yonedaEquiv_presheafHom_yoneda_obj
File: Mathlib/CategoryTheory/Limits/Presheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
ℰ : Type u₂
inst✝³ : Category.{v₁, u₂} ℰ
A✝ A : C ⥤ ℰ
inst✝² : yoneda.HasPointwiseLeftKanExtension A
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ Type v₁), F.op.HasLeftKanExtension P
X✝ : C
G : (Cᵒᵖ ⥤ Type v₁) ⥤ Dᵒᵖ ⥤ Type v₁
φ : F ⋙ yoneda ⟶ yoneda ⋙ G
X : C
⊢ yonedaEquiv (presheafHom φ (yoneda.obj X)) =
    (φ.app X).app (F.op.obj (Opposite.op X)) (𝟙 (Opposite.unop (F.op.obj (Opposite.op X))))
state_after: no goals
tactic: simpa using yonedaEquiv_ι_presheafHom φ (yoneda.obj X) (𝟙 _)
Theorem: dimH_countable
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
hs : s.Countable
⊢ dimH (⋃ x ∈ s, {x}) = 0
state_after: no goals
tactic: simp only [dimH_bUnion hs, dimH_singleton, ENNReal.iSup_zero_eq_zero]
Theorem: WeakDual.CharacterSpace.mem_spectrum_iff_exists
File: Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : NormedCommRing A
inst✝² : NormedAlgebra ℂ A
inst✝¹ : CompleteSpace A
I : Ideal A
inst✝ : I.IsMaximal
a : A
z : ℂ
⊢ z ∈ spectrum ℂ a ↔ ∃ f, f a = z
state_after: case refine_1
A : Type u_1
inst✝³ : NormedCommRing A
inst✝² : NormedAlgebra ℂ A
inst✝¹ : CompleteSpace A
I : Ideal A
inst✝ : I.IsMaximal
a : A
z : ℂ
hz : z ∈ spectrum ℂ a
⊢ ∃ f, f a = z

case refine_2
A : Type u_1
inst✝³ : NormedCommRing A
inst✝² : NormedAlgebra ℂ A
inst✝¹ : CompleteSpace A
I : Ideal A
inst✝ : I.IsMaximal
a : A
z : ℂ
⊢ (∃ f, f a = z) → z ∈ spectrum ℂ a
tactic: refine ⟨fun hz => ?_, ?_⟩