ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.HasBasis.equicontinuousAt_iff_right
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → X → α
x₀ : X
hα : (𝓤 α).HasBasis p s
⊢ EquicontinuousAt F x₀ ↔ ∀ (k : κ), p k → ∀ᶠ (x : X) in 𝓝 x₀, ∀ (i : ι), (F i x₀, F i x) ∈ s k
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → X → α
x₀ : X
hα : (𝓤 α).HasBasis p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : X) in 𝓝 x₀,
          (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α (s i)}) ↔
    ∀ (k : κ), p k → ∀ᶠ (x : X) in 𝓝 x₀, ∀ (i : ι), (F i x₀, F i x) ∈ s k
tactic: rw [equicontinuousAt_iff_continuousAt, ContinuousAt,
    (UniformFun.hasBasis_nhds_of_basis ι α _ hα).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set (α × α)
F : ι → X → α
x₀ : X
hα : (𝓤 α).HasBasis p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : X) in 𝓝 x₀,
          (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α (s i)}) ↔
    ∀ (k : κ), p k → ∀ᶠ (x : X) in 𝓝 x₀, ∀ (i : ι), (F i x₀, F i x) ∈ s k
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.lintegral_trim
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∀ (c : ℝ≥0∞) ⦃s : Set α⦄,
    MeasurableSet s → (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) (s.indicator fun x => c)

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∀ ⦃f g : α → ℝ≥0∞⦄,
    Disjoint (support f) (support g) →
      Measurable f →
        Measurable g →
          (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) f →
            (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) g →
              (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) (f + g)

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∀ ⦃f : ℕ → α → ℝ≥0∞⦄,
    (∀ (n : ℕ), Measurable (f n)) →
      Monotone f →
        (∀ (n : ℕ), (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) (f n)) →
          (fun f => ∫⁻ (a : α), f a ∂μ.trim hm = ∫⁻ (a : α), f a ∂μ) fun x => ⨆ n, f n x
tactic: refine
    @Measurable.ennreal_induction α m (fun f => ∫⁻ a, f a ∂μ.trim hm = ∫⁻ a, f a ∂μ) ?_ ?_ ?_ f hf
Theorem: norm_fderivWithin_iteratedFDerivWithin
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
n : ℕ
⊢ ‖fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 n f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n + 1) f s x‖
state_after: no goals
tactic: rw [iteratedFDerivWithin_succ_eq_comp_left, comp_apply, LinearIsometryEquiv.norm_map]
Theorem: Batteries.RBNode.Balanced.alter
File: .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean

Proof steps:
state_before: α : Type u_1
c : RBColor
n : Nat
cut : α → Ordering
f : Option α → Option α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c n, (alter cut f t).Balanced c n
state_after: α : Type u_1
c : RBColor
n : Nat
cut : α → Ordering
f : Option α → Option α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c n,
    (match zoom cut t with
        | (nil, path) =>
          match f none with
          | none => t
          | some y => path.insertNew y
        | (node c a x b, path) =>
          match f (some x) with
          | none => path.del (a.append b) c
          | some y => path.fill (node c a y b)).Balanced
      c n
tactic: simp [alter]
state_before: α : Type u_1
c : RBColor
n : Nat
cut : α → Ordering
f : Option α → Option α
t : RBNode α
h : t.Balanced c n
⊢ ∃ c n,
    (match zoom cut t with
        | (nil, path) =>
          match f none with
          | none => t
          | some y => path.insertNew y
        | (node c a x b, path) =>
          match f (some x) with
          | none => path.del (a.append b) c
          | some y => path.fill (node c a y b)).Balanced
      c n
state_after: case h_1
α : Type u_1
c : RBColor
n : Nat
cut : α → Ordering
f : Option α → Option α
t : RBNode α
h : t.Balanced c n
x✝ : RBNode α × Path α
snd✝ : Path α
heq✝ : zoom cut t = (nil, snd✝)
⊢ ∃ c n,
    (match f none with
        | none => t
        | some y => snd✝.insertNew y).Balanced
      c n

case h_2
α : Type u_1
c : RBColor
n : Nat
cut : α → Ordering
f : Option α → Option α
t : RBNode α
h : t.Balanced c n
x✝¹ : RBNode α × Path α
c✝ : RBColor
a✝ : RBNode α
x✝ : α
b✝ : RBNode α
path✝ : Path α
heq✝ : zoom cut t = (node c✝ a✝ x✝ b✝, path✝)
⊢ ∃ c n,
    (match f (some x✝) with
        | none => path✝.del (a✝.append b✝) c✝
        | some y => path✝.fill (node c✝ a✝ y b✝)).Balanced
      c n
tactic: split
Theorem: Real.hasSum_log_one_add_inv
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

Proof steps:
state_before: a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
⊢ HasSum (fun k => 2 * (1 / (2 * ↑k + 1)) * (1 / (2 * a + 1)) ^ (2 * k + 1)) (log (1 + a⁻¹))
state_after: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
tactic: convert hasSum_log_sub_log_of_abs_lt_one h₁ using 1
state_before: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
state_after: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
tactic: have h₂ : (2 : ℝ) * a + 1 ≠ 0 := by linarith
state_before: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
state_after: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
h₃ : a ≠ 0
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
tactic: have h₃ := h.ne'
state_before: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
h₃ : a ≠ 0
⊢ log (1 + a⁻¹) = log (1 + 1 / (2 * a + 1)) - log (1 - 1 / (2 * a + 1))
state_after: case h.e'_6
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
h₃ : a ≠ 0
⊢ log (1 + a⁻¹) = log ((1 + 1 / (2 * a + 1)) / (1 - 1 / (2 * a + 1)))

case h.e'_6.hx
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
h₃ : a ≠ 0
⊢ 1 + 1 / (2 * a + 1) ≠ 0

case h.e'_6.hy
a : ℝ
h : 0 < a
h₁ : |1 / (2 * a + 1)| < 1
h₂ : 2 * a + 1 ≠ 0
h₃ : a ≠ 0
⊢ 1 - 1 / (2 * a + 1) ≠ 0
tactic: rw [← log_div]
Theorem: AffineIsometry.edist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁴ : NormedField 𝕜
inst✝²³ : SeminormedAddCommGroup V
inst✝²² : NormedSpace 𝕜 V
inst✝²¹ : PseudoMetricSpace P
inst✝²⁰ : NormedAddTorsor V P
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : NormedSpace 𝕜 V₁
inst✝¹⁷ : PseudoMetricSpace P₁
inst✝¹⁶ : NormedAddTorsor V₁ P₁
inst✝¹⁵ : SeminormedAddCommGroup V₁'
inst✝¹⁴ : NormedSpace 𝕜 V₁'
inst✝¹³ : MetricSpace P₁'
inst✝¹² : NormedAddTorsor V₁' P₁'
inst✝¹¹ : SeminormedAddCommGroup V₂
inst✝¹⁰ : NormedSpace 𝕜 V₂
inst✝⁹ : PseudoMetricSpace P₂
inst✝⁸ : NormedAddTorsor V₂ P₂
inst✝⁷ : SeminormedAddCommGroup V₃
inst✝⁶ : NormedSpace 𝕜 V₃
inst✝⁵ : PseudoMetricSpace P₃
inst✝⁴ : NormedAddTorsor V₃ P₃
inst✝³ : SeminormedAddCommGroup V₄
inst✝² : NormedSpace 𝕜 V₄
inst✝¹ : PseudoMetricSpace P₄
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁' →ᵃⁱ[𝕜] P₂
x y : P
⊢ edist (f x) (f y) = edist x y
state_after: no goals
tactic: simp [edist_dist]
Theorem: Set.image_update_Ioc_right
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Ioc (f i) b = Ioc f (update f i b)
state_after: no goals
tactic: simpa using image_update_Ioc f i (f i) b
Theorem: CategoryTheory.ProjectiveResolution.lift_commutes_zero
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Y ⟶ Z
P : ProjectiveResolution Y
Q : ProjectiveResolution Z
⊢ (P.π ≫ (ChainComplex.single₀ C).map f).f 0 = P.π.f 0 ≫ f
state_after: no goals
tactic: simp
Theorem: Multiset.nodup_bind
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
this : ∀ (a : α), ∃ l, f a = ↑l
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
tactic: have : ∀ a, ∃ l : List β, f a = l := fun a => Quot.induction_on (f a) fun l => ⟨l, rfl⟩
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
this : ∀ (a : α), ∃ l, f a = ↑l
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
tactic: choose f' h' using this
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
this : f = fun a => ↑(f' a)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
tactic: have : f = fun a ↦ ofList (f' a) := funext h'
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
this : f = fun a => ↑(f' a)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
this : f = fun a => ↑(f' a)
hd : Symmetric fun a b => (f' a).Disjoint (f' b)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
tactic: have hd : Symmetric fun a b ↦ List.Disjoint (f' a) (f' b) := fun a b h ↦ h.symm
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
f' : α → List β
h' : ∀ (a : α), f a = ↑(f' a)
this : f = fun a => ↑(f' a)
hd : Symmetric fun a b => (f' a).Disjoint (f' b)
⊢ (s.bind f).Nodup ↔ (∀ a ∈ s, (f a).Nodup) ∧ Pairwise (fun a b => (f a).Disjoint (f b)) s
state_after: no goals
tactic: exact Quot.induction_on s <| by simp [this, List.nodup_bind, pairwise_coe_iff_pairwise hd]
Theorem: LieModule.Weight.IsZero.neg
File: Mathlib/Algebra/Lie/Weights/Killing.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
inst✝² : IsKilling K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : Weight K (↥H) L
h : α.IsZero
⊢ (-α).IsZero
state_after: case h
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
inst✝² : IsKilling K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : Weight K (↥H) L
h : α.IsZero
x✝ : ↥H
⊢ (-α) x✝ = 0 x✝
tactic: ext
state_before: case h
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : Field K
inst✝⁴ : LieAlgebra K L
inst✝³ : FiniteDimensional K L
inst✝² : IsKilling K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α : Weight K (↥H) L
h : α.IsZero
x✝ : ↥H
⊢ (-α) x✝ = 0 x✝
state_after: no goals
tactic: rw [coe_neg, h, neg_zero]
Theorem: Real.exp_approx_end'
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: n : ℕ
x a b : ℝ
m : ℕ
e₁ : n + 1 = m
rm : ℝ
er : ↑m = rm
h : |x| ≤ 1
e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm)
⊢ |rexp x - expNear n x a| ≤ |x| ^ n / ↑n.factorial * b
state_after: n : ℕ
x a b : ℝ
m : ℕ
e₁ : n + 1 = m
h : |x| ≤ 1
e : |1 - a| ≤ b - |x| / ↑m * ((↑m + 1) / ↑m)
⊢ |rexp x - expNear n x a| ≤ |x| ^ n / ↑n.factorial * b
tactic: subst er
state_before: n : ℕ
x a b : ℝ
m : ℕ
e₁ : n + 1 = m
h : |x| ≤ 1
e : |1 - a| ≤ b - |x| / ↑m * ((↑m + 1) / ↑m)
⊢ |rexp x - expNear n x a| ≤ |x| ^ n / ↑n.factorial * b
state_after: no goals
tactic: exact exp_approx_succ _ e₁ _ _ (by simpa using e) (exp_approx_end _ _ _ e₁ h)
Theorem: OneOneReducible.of_equiv_symm
File: Mathlib/Computability/Reduce.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q ≤₁ (q ∘ ⇑e)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q = (q ∘ ⇑e) ∘ ⇑e.symm
tactic: convert OneOneReducible.of_equiv _ h
state_before: case h.e'_5
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
⊢ q = (q ∘ ⇑e) ∘ ⇑e.symm
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
x✝ : β
⊢ q x✝ = ((q ∘ ⇑e) ∘ ⇑e.symm) x✝
tactic: funext
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
e : α ≃ β
q : β → Prop
h : Computable ⇑e.symm
x✝ : β
⊢ q x✝ = ((q ∘ ⇑e) ∘ ⇑e.symm) x✝
state_after: no goals
tactic: simp
Theorem: Nat.div_pos
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : b ≤ a
hb : 0 < b
h : a / b = 0
⊢ a = a % b
state_after: no goals
tactic: simpa [h] using (mod_add_div a b).symm
Theorem: NumberField.mixedEmbedding.norm_le_convexBodySumFun
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ ‖x‖ ≤ convexBodySumFun x
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ (Finset.univ.sup' ⋯ fun w => (normAtPlace w) x) ≤ convexBodySumFun x
tactic: rw [norm_eq_sup'_normAtPlace]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ (Finset.univ.sup' ⋯ fun w => (normAtPlace w) x) ≤ convexBodySumFun x
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ (normAtPlace w) x ≤ convexBodySumFun x
tactic: refine (Finset.sup'_le_iff _ _).mpr fun w _ ↦ ?_
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ (normAtPlace w) x ≤ convexBodySumFun x
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ (normAtPlace w) x ≤ ↑w.mult * (normAtPlace w) x + ∑ x_1 ∈ Finset.univ.erase w, ↑x_1.mult * (normAtPlace x_1) x
tactic: rw [convexBodySumFun_apply, ← Finset.univ.add_sum_erase _ (Finset.mem_univ w)]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ (normAtPlace w) x ≤ ↑w.mult * (normAtPlace w) x + ∑ x_1 ∈ Finset.univ.erase w, ↑x_1.mult * (normAtPlace x_1) x
state_after: case refine_1
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ (normAtPlace w) x ≤ ↑w.mult * (normAtPlace w) x

case refine_2
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
w : InfinitePlace K
x✝ : w ∈ Finset.univ
⊢ 0 ≤ ∑ x_1 ∈ Finset.univ.erase w, ↑x_1.mult * (normAtPlace x_1) x
tactic: refine le_add_of_le_of_nonneg  ?_ ?_
Theorem: CircleDeg1Lift.commute_add_nat
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ Function.Commute ⇑f fun x => x + ↑n
state_after: no goals
tactic: simp only [add_comm _ (n : ℝ), f.commute_nat_add n]
Theorem: MeasureTheory.Measure.toSphere_apply_univ
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

Proof steps:
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
a✝ : Nontrivial E
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)
tactic: nontriviality E
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
a✝ : Nontrivial E
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)
state_after: no goals
tactic: rw [toSphere_apply_univ', measure_diff_null (measure_singleton _)]
Theorem: Multiset.card_Iic
File: Mathlib/Data/Multiset/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Multiset α
⊢ (Finset.Iic s).card = ∏ i ∈ s.toFinset, (count i s + 1)
state_after: no goals
tactic: simp_rw [Iic_eq_Icc, card_Icc, bot_eq_zero, toFinset_zero, empty_union, count_zero, tsub_zero]
Theorem: CFC.log_exp
File: Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean

Proof steps:
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha : autoParam (IsSelfAdjoint a) _auto✝
⊢ log (exp ℝ a) = a
state_after: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha : autoParam (IsSelfAdjoint a) _auto✝
hcont : ContinuousOn Real.log (Real.exp '' spectrum ℝ a)
⊢ log (exp ℝ a) = a
tactic: have hcont : ContinuousOn Real.log (Real.exp '' spectrum ℝ a) := by fun_prop (disch := aesop)
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha : autoParam (IsSelfAdjoint a) _auto✝
hcont : ContinuousOn Real.log (Real.exp '' spectrum ℝ a)
⊢ log (exp ℝ a) = a
state_after: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha : autoParam (IsSelfAdjoint a) _auto✝
hcont : ContinuousOn Real.log (Real.exp '' spectrum ℝ a)
⊢ cfc (fun x => Real.log (Real.exp x)) a = a
tactic: rw [log, ← real_exp_eq_normedSpace_exp, ← cfc_comp' Real.log Real.exp a hcont]
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha : autoParam (IsSelfAdjoint a) _auto✝
hcont : ContinuousOn Real.log (Real.exp '' spectrum ℝ a)
⊢ cfc (fun x => Real.log (Real.exp x)) a = a
state_after: no goals
tactic: simp [cfc_id' (R := ℝ) a]