ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: mem_map_indicator_ae_iff_of_zero_nmem
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
t : Set β
ht : 0 ∉ t
⊢ t ∈ Filter.map (s.indicator f) (ae μ) ↔ μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0
state_after: no goals
tactic: classical
  rw [mem_map, mem_ae_iff, Set.indicator_preimage, Set.ite, Set.compl_union, Set.compl_inter]
  change μ (((f ⁻¹' t)ᶜ ∪ sᶜ) ∩ ((fun _ => (0 : β)) ⁻¹' t \ s)ᶜ) = 0 ↔ μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0
  simp only [ht, if_false, Set.compl_empty, Set.empty_diff, Set.inter_univ, Set.preimage_const]
Theorem: Function.isPeriodicPt_prod_map
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x✝ : α × β
a : α
b : β
m n : ℕ
x : α × β
⊢ IsPeriodicPt (Prod.map f g) n x ↔ IsPeriodicPt f n x.1 ∧ IsPeriodicPt g n x.2
state_after: no goals
tactic: simp [IsPeriodicPt]
Theorem: closure_iUnion_of_finite
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
inst✝ : Finite ι
f : ι → Set X
⊢ closure (⋃ i, f i) = ⋃ i, closure (f i)
state_after: no goals
tactic: rw [← sUnion_range, (finite_range _).closure_sUnion, biUnion_range]
Theorem: Real.cos_two_mul
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(cos (2 * x)) = ↑(2 * cos x ^ 2 - 1)
state_after: no goals
tactic: simp [cos_two_mul]
Theorem: IsOpen.exists_subset_affineIndependent_span_eq_top
File: Mathlib/Analysis/NormedSpace/AddTorsorBases.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
hne : u.Nonempty
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
state_after: case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
x : P
hx : x ∈ u
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
tactic: rcases hne with ⟨x, hx⟩
state_before: case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
x : P
hx : x ∈ u
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
state_after: case intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
x : P
hx : x ∈ u
s : Set P
hsu : s ⊆ u
hs : AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
tactic: rcases hu.exists_between_affineIndependent_span_eq_top (singleton_subset_iff.mpr hx)
    (singleton_nonempty _) (affineIndependent_of_subsingleton _ _) with ⟨s, -, hsu, hs⟩
state_before: case intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
x : P
hx : x ∈ u
s : Set P
hsu : s ⊆ u
hs : AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
state_after: no goals
tactic: exact ⟨s, hsu, hs⟩
Theorem: AddMonoidHom.mclosure_range
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : F
⊢ closure (Set.range ⇑f) = mrange f
state_after: no goals
tactic: rw [← Set.image_univ, ← map_mclosure, mrange_eq_map, closure_univ]
Theorem: FractionalIdeal.count_pow_self
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℕ
⊢ count K v (↑v.asIdeal ^ n) = ↑n
state_after: no goals
tactic: rw [count_pow, count_self, mul_one]
Theorem: Finset.AddETransform.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
      ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
    x.1.card + x.2.card + (x.1.card + x.2.card)
state_after: no goals
tactic: rw [add_add_add_comm, mulETransformLeft.card, mulETransformRight.card, ← mul_add, two_mul]
Theorem: vadd_iterate_apply
File: Mathlib/Algebra/GroupPower/IterateHom.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝¹ : Monoid G
a : G
n : ℕ
inst✝ : MulAction G H
b : H
⊢ (fun x => a • x)^[n] b = a ^ n • b
state_after: no goals
tactic: rw [smul_iterate]
Theorem: Finset.sum_Ioc_consecutive
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
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ (∏ i ∈ Ioc m n, f i) * ∏ i ∈ Ioc n k, f i = ∏ i ∈ Ioc m k, f i
state_after: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ Disjoint (Ioc m n) (Ioc n k)
tactic: rw [← Ioc_union_Ioc_eq_Ioc hmn hnk, prod_union]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ Disjoint (Ioc m n) (Ioc n k)
state_after: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ ∀ x ∈ Ioc m n, x ∈ Ioc n k → False
tactic: apply disjoint_left.2 fun x hx h'x => _
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ ∀ x ∈ Ioc m n, x ∈ Ioc n k → False
state_after: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
x : ℕ
hx : x ∈ Ioc m n
h'x : x ∈ Ioc n k
⊢ False
tactic: intros x hx h'x
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
x : ℕ
hx : x ∈ Ioc m n
h'x : x ∈ Ioc n k
⊢ False
state_after: no goals
tactic: exact lt_irrefl _ ((mem_Ioc.1 h'x).1.trans_le (mem_Ioc.1 hx).2)
Theorem: HasDerivAt.lhopital_zero_right_on_Ico
File: Mathlib/Analysis/Calculus/LHopital.lean

Proof steps:
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ x ∈ Ioo a b, g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
state_after: case refine_1
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ x ∈ Ioo a b, g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l
⊢ Tendsto f (𝓝[>] a) (𝓝 0)

case refine_2
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x
hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ x ∈ Ioo a b, g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l
⊢ Tendsto g (𝓝[>] a) (𝓝 0)
tactic: refine lhopital_zero_right_on_Ioo hab hff' hgg' hg' ?_ ?_ hdiv
Theorem: MeasureTheory.eLpNorm_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ eLpNorm (-f) p μ = eLpNorm f p μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : p = 0
⊢ eLpNorm (-f) p μ = eLpNorm f p μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
⊢ eLpNorm (-f) p μ = eLpNorm f p μ
tactic: by_cases h0 : p = 0
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
⊢ eLpNorm (-f) p μ = eLpNorm f p μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
h_top : p = ⊤
⊢ eLpNorm (-f) p μ = eLpNorm f p μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ eLpNorm (-f) p μ = eLpNorm f p μ
tactic: by_cases h_top : p = ∞
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ eLpNorm (-f) p μ = eLpNorm f p μ
state_after: no goals
tactic: simp [eLpNorm_eq_eLpNorm' h0 h_top]
Theorem: Set.le_einfsep_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
d : ℝ≥0∞
⊢ d ≤ s.einfsep ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y
state_after: no goals
tactic: simp_rw [einfsep, le_iInf_iff]
Theorem: LinearMap.adjoint_comp
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
⊢ adjoint (A ∘ₗ B) = adjoint B ∘ₗ adjoint A
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
⊢ (adjoint (A ∘ₗ B)) v = (adjoint B ∘ₗ adjoint A) v
tactic: ext v
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
⊢ (adjoint (A ∘ₗ B)) v = (adjoint B ∘ₗ adjoint A) v
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
w : E
⊢ ⟪w, (adjoint (A ∘ₗ B)) v⟫_𝕜 = ⟪w, (adjoint B ∘ₗ adjoint A) v⟫_𝕜
tactic: refine ext_inner_left 𝕜 fun w => ?_
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
w : E
⊢ ⟪w, (adjoint (A ∘ₗ B)) v⟫_𝕜 = ⟪w, (adjoint B ∘ₗ adjoint A) v⟫_𝕜
state_after: no goals
tactic: simp only [adjoint_inner_right, LinearMap.coe_comp, Function.comp_apply]
Theorem: continuousWithinAt_Ico_iff_Iio
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Ico a b) b ↔ ContinuousWithinAt f (Iio b) b
state_after: no goals
tactic: simp only [ContinuousWithinAt, nhdsWithin_Ico_eq_nhdsWithin_Iio h]
Theorem: riemannZeta_one
File: Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean

Proof steps:
state_before: ⊢ riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
state_after: this :
  Tendsto (fun s => HurwitzZeta.hurwitzZetaEven 0 s - 1 / (s - 1) / s.Gammaℝ) (𝓝[≠] 1)
    (𝓝 (HurwitzZeta.hurwitzZetaEven 0 1))
⊢ riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
tactic: have := (HurwitzZeta.tendsto_hurwitzZetaEven_sub_one_div_nhds_one 0).mono_left
    <| nhdsWithin_le_nhds (s := {1}ᶜ)
state_before: this :
  Tendsto (fun s => HurwitzZeta.hurwitzZetaEven 0 s - 1 / (s - 1) / s.Gammaℝ) (𝓝[≠] 1)
    (𝓝 (HurwitzZeta.hurwitzZetaEven 0 1))
⊢ riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
state_after: this : Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 (riemannZeta 1))
⊢ riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
tactic: simp only [HurwitzZeta.hurwitzZetaEven_zero, div_right_comm _ _ (Gammaℝ _)] at this
state_before: this : Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 (riemannZeta 1))
⊢ riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
state_after: no goals
tactic: exact tendsto_nhds_unique this tendsto_riemannZeta_sub_one_div_Gammaℝ
Theorem: MeasureTheory.SignedMeasure.singularPart_zero
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
⊢ singularPart 0 μ = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
⊢ 0 = 0 + μ.withDensityᵥ 0
tactic: refine (eq_singularPart 0 0 VectorMeasure.MutuallySingular.zero_left ?_).symm
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
⊢ 0 = 0 + μ.withDensityᵥ 0
state_after: no goals
tactic: rw [zero_add, withDensityᵥ_zero]
Theorem: Holor.cprankMax_mul
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α [d]
⊢ CPRankMax 0 (x ⊗ 0)
state_after: no goals
tactic: simp [mul_zero x, CPRankMax.zero]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax (n + 1) (x ⊗ (y₁ + y₂))
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax (n + 1) (x ⊗ y₁ + x ⊗ y₂)
tactic: rw [mul_left_distrib]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax (n + 1) (x ⊗ y₁ + x ⊗ y₂)
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax (1 + n) (x ⊗ y₁ + x ⊗ y₂)
tactic: rw [Nat.add_comm]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax (1 + n) (x ⊗ y₁ + x ⊗ y₂)
state_after: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax 1 (x ⊗ y₁)

case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : y₁.CPRankMax1
hy₂ : CPRankMax n y₂
⊢ CPRankMax n (x ⊗ y₂)
tactic: apply cprankMax_add
Theorem: Multiset.noncommFold_coe
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
assoc : Std.Associative op
l : List α
comm : {x | x ∈ ↑l}.Pairwise fun x y => op x y = op y x
a : α
⊢ noncommFold op (↑l) comm a = List.foldr op a l
state_after: no goals
tactic: simp [noncommFold]
Theorem: UpperHalfPlane.dist_coe_le
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

Proof steps:
state_before: z✝ w✝ : ℍ
r R : ℝ
z w : ℍ
⊢ dist ↑z ↑(w.center (dist z w)) + dist ↑w ↑(w.center (dist z w)) = w.im * (rexp (dist z w) - 1)
state_after: no goals
tactic: rw [dist_center_dist, dist_self_center, ← mul_add, ← add_sub_assoc, Real.sinh_add_cosh]
Theorem: div_eq_inv_self
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 / b = b⁻¹ ↔ a = 1
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_left_eq_self]
Theorem: Polynomial.support_C_mul_X'
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
c : R
⊢ (C c * X).support ⊆ {1}
state_after: no goals
tactic: simpa only [C_mul_X_eq_monomial] using support_monomial' 1 c
Theorem: Filter.limsup_bot
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : β → α
⊢ limsup f ⊥ = ⊥
state_after: no goals
tactic: simp [limsup]
Theorem: MeasureTheory.crossing_eq_crossing_of_lowerCrossingTime_lt
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : lowerCrossingTime a b f N n ω < N
⊢ upperCrossingTime a b f M n ω = upperCrossingTime a b f N n ω ∧
    lowerCrossingTime a b f M n ω = lowerCrossingTime a b f N n ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : lowerCrossingTime a b f N n ω < N
h' : upperCrossingTime a b f N n ω < N
⊢ upperCrossingTime a b f M n ω = upperCrossingTime a b f N n ω ∧
    lowerCrossingTime a b f M n ω = lowerCrossingTime a b f N n ω
tactic: have h' : upperCrossingTime a b f N n ω < N :=
    lt_of_le_of_lt upperCrossingTime_le_lowerCrossingTime h
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : lowerCrossingTime a b f N n ω < N
h' : upperCrossingTime a b f N n ω < N
⊢ upperCrossingTime a b f M n ω = upperCrossingTime a b f N n ω ∧
    lowerCrossingTime a b f M n ω = lowerCrossingTime a b f N n ω
state_after: case zero
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : lowerCrossingTime a b f N 0 ω < N
h' : upperCrossingTime a b f N 0 ω < N
⊢ upperCrossingTime a b f M 0 ω = upperCrossingTime a b f N 0 ω ∧
    lowerCrossingTime a b f M 0 ω = lowerCrossingTime a b f N 0 ω

case succ
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
k : ℕ
ih :
  lowerCrossingTime a b f N k ω < N →
    upperCrossingTime a b f N k ω < N →
      upperCrossingTime a b f M k ω = upperCrossingTime a b f N k ω ∧
        lowerCrossingTime a b f M k ω = lowerCrossingTime a b f N k ω
h : lowerCrossingTime a b f N (k + 1) ω < N
h' : upperCrossingTime a b f N (k + 1) ω < N
⊢ upperCrossingTime a b f M (k + 1) ω = upperCrossingTime a b f N (k + 1) ω ∧
    lowerCrossingTime a b f M (k + 1) ω = lowerCrossingTime a b f N (k + 1) ω
tactic: induction' n with k ih
Theorem: MeasureTheory.MeasurePreserving.restrict_preimage
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f μa μb
s : Set β
hs : MeasurableSet s
⊢ map f (μa.restrict (f ⁻¹' s)) = μb.restrict s
state_after: no goals
tactic: rw [← hf.map_eq, restrict_map hf.measurable hs]
Theorem: List.reduceOption_map
File: Mathlib/Data/List/ReduceOption.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
f : α → β
⊢ (map (Option.map f) l).reduceOption = map f l.reduceOption
state_after: case nil
α : Type u_1
β : Type u_2
f : α → β
⊢ (map (Option.map f) []).reduceOption = map f [].reduceOption

case cons
α : Type u_1
β : Type u_2
f : α → β
hd : Option α
tl : List (Option α)
hl : (map (Option.map f) tl).reduceOption = map f tl.reduceOption
⊢ (map (Option.map f) (hd :: tl)).reduceOption = map f (hd :: tl).reduceOption
tactic: induction' l with hd tl hl
Theorem: min_le_of_mul_le_sq
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : LinearOrder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : M
h : a * b ≤ c ^ 2
⊢ min a b ≤ c
state_after: no goals
tactic: simpa using min_le_max_of_mul_le_mul (h.trans_eq <| pow_two _)
Theorem: alexDiscEquivPreord_inverse_obj
File: Mathlib/Topology/Order/Category/AlexDisc.lean

Proof steps:
state_before: X : AlexDisc
⊢ ↑((𝟭 AlexDisc).obj X) ≃ₜ
    ↑(((forget₂ AlexDisc TopCat ⋙ topToPreord) ⋙
            { obj := fun X => AlexDisc.of (WithUpperSet ↑X), map := fun {X Y} => WithUpperSet.map, map_id := ⋯,
              map_comp := ⋯ }).obj
        X)
state_after: X : AlexDisc
⊢ ↑X ≃ₜ WithUpperSet (Specialization ↑X)
tactic: dsimp
state_before: X : AlexDisc
⊢ ↑X ≃ₜ WithUpperSet (Specialization ↑X)
state_after: no goals
tactic: exact homeoWithUpperSetTopologyorderIso X
state_before: X : Preord
⊢ ↑(({ obj := fun X => AlexDisc.of (WithUpperSet ↑X), map := fun {X Y} => WithUpperSet.map, map_id := ⋯,
              map_comp := ⋯ } ⋙
            forget₂ AlexDisc TopCat ⋙ topToPreord).obj
        X) ≃o
    ↑((𝟭 Preord).obj X)
state_after: X : Preord
⊢ Specialization (WithUpperSet ↑X) ≃o ↑X
tactic: dsimp
state_before: X : Preord
⊢ Specialization (WithUpperSet ↑X) ≃o ↑X
state_after: no goals
tactic: exact (orderIsoSpecializationWithUpperSetTopology X).symm