1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Measurable.prod
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: rw [MeasurableSpace.comap_le_iff_le_map, MeasurableSpace.map_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ MeasurableSpace.comap Prod.fst mβ ≤ MeasurableSpace.map f m
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ mβ ≤ MeasurableSpace.map (Prod.fst ∘ f) m

tactic: exact hf₁
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ mβ ≤ MeasurableSpace.map (Prod.fst ∘ f) m
state_after: no goals

tactic: rw [MeasurableSpace.comap_le_iff_le_map, MeasurableSpace.map_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ MeasurableSpace.comap Prod.snd mγ ≤ MeasurableSpace.map f m
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ mγ ≤ MeasurableSpace.map (Prod.snd ∘ f) m

tactic: exact hf₂
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : α → β × γ
hf₁ : Measurable fun a => (f a).1
hf₂ : Measurable fun a => (f a).2
⊢ mγ ≤ MeasurableSpace.map (Prod.snd ∘ f) m
state_after: no goals
Theorem: MatrixEquivTensor.invFun_add
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: simp [invFun, add_tmul, Finset.sum_add_distrib]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M N : Matrix n n A
⊢ invFun R A n (M + N) = invFun R A n M + invFun R A n N
state_after: no goals
Theorem: Antitone.piecewise_eventually_eq_iInter
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: convert ← (compl_anti.comp hs).piecewise_eventually_eq_iUnion g f a using 3
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋂ i, s i
hs : Antitone s
f g : (a : α) → β a
a : α
⊢ ∀ᶠ (i : ι) in atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a
state_after: case h.e'_2.h.h.e'_2
ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋂ i, s i
hs : Antitone s
f g : (a : α) → β a
a : α
x✝ : ι
⊢ ((compl ∘ s) x✝).piecewise g f a = (s x✝).piecewise f g a

case h.e'_2.h.h.e'_3
ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋂ i, s i
hs : Antitone s
f g : (a : α) → β a
a : α
x✝ : ι
⊢ (⋃ i, (compl ∘ s) i).piecewise g f a = (⋂ i, s i).piecewise f g a

tactic: convert congr_fun (Set.piecewise_compl (s _) g f) a
state_before: case h.e'_2.h.h.e'_2
ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋂ i, s i
hs : Antitone s
f g : (a : α) → β a
a : α
x✝ : ι
⊢ ((compl ∘ s) x✝).piecewise g f a = (s x✝).piecewise f g a
state_after: no goals
Theorem: List.length_iterate
File: Mathlib/Data/List/Iterate.lean

tactic: induction n generalizing a <;> simp [*]
state_before: α : Type u_1
f : α → α
a : α
n : ℕ
⊢ (iterate f a n).length = n
state_after: no goals
Theorem: Complex.norm_max_aux₂
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: set e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
⊢ ‖f w‖ = ‖f z‖
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
⊢ ‖f w‖ = ‖f z‖

tactic: have he : ∀ x, ‖e x‖ = ‖x‖ := UniformSpace.Completion.norm_coe
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
⊢ ‖f w‖ = ‖f z‖
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
he : ∀ (x : F), ‖e x‖ = ‖x‖
⊢ ‖f w‖ = ‖f z‖
Theorem: Euclidean.isCompact_closedBall
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [closedBall_eq_image]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (closedBall x r)
state_after: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (⇑toEuclidean.symm '' Metric.closedBall (toEuclidean x) r)

tactic: exact (isCompact_closedBall _ _).image toEuclidean.symm.continuous
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (⇑toEuclidean.symm '' Metric.closedBall (toEuclidean x) r)
state_after: no goals
Theorem: IsPrimitiveRoot.finite_quotient_span_sub_one'
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: have : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K := by simpa using hcycl
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})

tactic: replace hζ : IsPrimitiveRoot ζ (p ^ (0 + 1)) := by simpa using hζ
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ Finite (𝓞 K ⧸ Ideal.span {hζ.toInteger - 1})
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ Finite (𝓞 K ⧸ Ideal.span {hζ✝.toInteger - 1})

tactic: exact hζ.finite_quotient_span_sub_one
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ Finite (𝓞 K ⧸ Ideal.span {hζ✝.toInteger - 1})
state_after: no goals

tactic: simpa using hcycl
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
state_after: no goals

tactic: simpa using hζ
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ IsPrimitiveRoot ζ (↑p ^ (0 + 1))
state_after: no goals
Theorem: Real.sin_sq_le_one
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq_add_cos_sq x]
state_before: x y : ℝ
⊢ sin x ^ 2 ≤ 1
state_after: x y : ℝ
⊢ sin x ^ 2 ≤ sin x ^ 2 + cos x ^ 2

tactic: exact le_add_of_nonneg_right (sq_nonneg _)
state_before: x y : ℝ
⊢ sin x ^ 2 ≤ sin x ^ 2 + cos x ^ 2
state_after: no goals
Theorem: Asymptotics.isBigO_atTop_iff_eventually_exists_pos
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp_rw [isBigO_iff'', ← exists_prop, Subtype.exists', exists_eventually_atTop]
state_before: α✝ : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α✝ → E
g✝ : α✝ → F
k : α✝ → G
f' : α✝ → E'
g' : α✝ → F'
k' : α✝ → G'
f'' : α✝ → E''
g'' : α✝ → F''
k'' : α✝ → G''
l l' : Filter α✝
α : Type u_17
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
f : α → G
g : α → G'
⊢ f =O[atTop] g ↔ ∀ᶠ (n₀ : α) in atTop, ∃ c > 0, ∀ n ≥ n₀, c * ‖f n‖ ≤ ‖g n‖
state_after: no goals
Theorem: Function.Periodic.const_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: by_cases ha : a = 0
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : ¬a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x

tactic: simp only [ha, zero_smul]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
state_after: no goals

tactic: simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
x : α
ha : ¬a = 0
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
state_after: no goals
Theorem: gal_X_pow_isSolvable
File: Mathlib/FieldTheory/AbelRuffini.lean

tactic: infer_instance
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
n : ℕ
⊢ IsSolvable (X ^ n).Gal
state_after: no goals
Theorem: Multiset.Ioo_self
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ioo, Finset.Ioo_self, Finset.empty_val]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Ioo a a = 0
state_after: no goals
Theorem: volume_regionBetween_eq_integral'
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

tactic: have h : g - f =ᵐ[μ.restrict s] fun x => Real.toNNReal (g x - f x) :=
  hfg.mono fun x hx => (Real.coe_toNNReal _ <| sub_nonneg.2 hx).symm
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
inst✝ : SigmaFinite μ
f_int : IntegrableOn f s μ
g_int : IntegrableOn g s μ
hs : MeasurableSet s
hfg : f ≤ᶠ[ae (μ.restrict s)] g
⊢ (μ.prod volume) (regionBetween f g s) = ENNReal.ofReal (∫ (y : α) in s, (g - f) y ∂μ)
state_after: α : Type u_1
inst✝¹ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
inst✝ : SigmaFinite μ
f_int : IntegrableOn f s μ
g_int : IntegrableOn g s μ
hs : MeasurableSet s
hfg : f ≤ᶠ[ae (μ.restrict s)] g
h : g - f =ᶠ[ae (μ.restrict s)] fun x => ↑(g x - f x).toNNReal
⊢ (μ.prod volume) (regionBetween f g s) = ENNReal.ofReal (∫ (y : α) in s, (g - f) y ∂μ)

tactic: rw [volume_regionBetween_eq_lintegral f_int.aemeasurable g_int.aemeasurable hs,
  integral_congr_ae h, lintegral_congr_ae,
  lintegral_coe_eq_integral _ ((integrable_congr h).mp (g_int.sub f_int))]
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
inst✝ : SigmaFinite μ
f_int : IntegrableOn f s μ
g_int : IntegrableOn g s μ
hs : MeasurableSet s
hfg : f ≤ᶠ[ae (μ.restrict s)] g
h : g - f =ᶠ[ae (μ.restrict s)] fun x => ↑(g x - f x).toNNReal
⊢ (μ.prod volume) (regionBetween f g s) = ENNReal.ofReal (∫ (y : α) in s, (g - f) y ∂μ)
state_after: α : Type u_1
inst✝¹ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
inst✝ : SigmaFinite μ
f_int : IntegrableOn f s μ
g_int : IntegrableOn g s μ
hs : MeasurableSet s
hfg : f ≤ᶠ[ae (μ.restrict s)] g
h : g - f =ᶠ[ae (μ.restrict s)] fun x => ↑(g x - f x).toNNReal
⊢ (fun y => ENNReal.ofReal ((g - f) y)) =ᶠ[ae (μ.restrict s)] fun a => ↑(g a - f a).toNNReal

tactic: rfl
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
inst✝ : SigmaFinite μ
f_int : IntegrableOn f s μ
g_int : IntegrableOn g s μ
hs : MeasurableSet s
hfg : f ≤ᶠ[ae (μ.restrict s)] g
h : g - f =ᶠ[ae (μ.restrict s)] fun x => ↑(g x - f x).toNNReal
⊢ (fun y => ENNReal.ofReal ((g - f) y)) =ᶠ[ae (μ.restrict s)] fun a => ↑(g a - f a).toNNReal
state_after: no goals
Theorem: ProbabilityTheory.kernel.densityProcess_empty
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

tactic: simp [densityProcess]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν✝ : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
n : ℕ
a : α
x : γ
⊢ densityProcess κ ν n a x ∅ = 0
state_after: no goals
Theorem: isClosed_preCantorSet
File: Mathlib/Topology/Instances/CantorSet.lean

tactic: let f := Homeomorph.mulLeft₀ (1 / 3 : ℝ) (by norm_num)
state_before: n : ℕ
⊢ IsClosed (preCantorSet n)
state_after: n : ℕ
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
⊢ IsClosed (preCantorSet n)

tactic: let g := (Homeomorph.addLeft (2 : ℝ)).trans f
state_before: n : ℕ
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
⊢ IsClosed (preCantorSet n)
state_after: n : ℕ
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
⊢ IsClosed (preCantorSet n)

tactic: norm_num
state_before: n : ℕ
⊢ 1 / 3 ≠ 0
state_after: no goals

tactic: exact isClosed_Icc
state_before: case zero
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
⊢ IsClosed (preCantorSet 0)
state_after: no goals

tactic: refine IsClosed.union ?_ ?_
state_before: case succ
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
n : ℕ
ih : IsClosed (preCantorSet n)
⊢ IsClosed (preCantorSet (n + 1))
state_after: case succ.refine_1
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
n : ℕ
ih : IsClosed (preCantorSet n)
⊢ IsClosed ((fun x => x / 3) '' preCantorSet n)

case succ.refine_2
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
n : ℕ
ih : IsClosed (preCantorSet n)
⊢ IsClosed ((fun x => (2 + x) / 3) '' preCantorSet n)

tactic: simpa [f, div_eq_inv_mul] using f.closedEmbedding.closed_iff_image_closed.mp ih
state_before: case succ.refine_1
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
n : ℕ
ih : IsClosed (preCantorSet n)
⊢ IsClosed ((fun x => x / 3) '' preCantorSet n)
state_after: no goals

tactic: simpa [g, f, div_eq_inv_mul] using g.closedEmbedding.closed_iff_image_closed.mp ih
state_before: case succ.refine_2
f : ℝ ≃ₜ ℝ := Homeomorph.mulLeft₀ (1 / 3) ⋯
g : ℝ ≃ₜ ℝ := (Homeomorph.addLeft 2).trans f
n : ℕ
ih : IsClosed (preCantorSet n)
⊢ IsClosed ((fun x => (2 + x) / 3) '' preCantorSet n)
state_after: no goals
Theorem: padicValRat.min_le_padicValRat_add
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [min_eq_left h]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p q ≤ padicValRat p r
⊢ min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p q ≤ padicValRat p r
⊢ padicValRat p q ≤ padicValRat p (q + r)

tactic: exact le_padicValRat_add_of_le hqr h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p q ≤ padicValRat p r
⊢ padicValRat p q ≤ padicValRat p (q + r)
state_after: no goals

tactic: rw [min_eq_right h, add_comm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ padicValRat p r ≤ padicValRat p (r + q)

tactic: exact le_padicValRat_add_of_le (by rwa [add_comm]) h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ padicValRat p r ≤ padicValRat p (r + q)
state_after: no goals

tactic: rwa [add_comm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ r + q ≠ 0
state_after: no goals
Theorem: Real.sqrt_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [Real.sqrt, Real.sqrt, NNReal.coe_le_coe, NNReal.sqrt_le_sqrt]
state_before: x y : ℝ
h : x ≤ y
⊢ √x ≤ √y
state_after: x y : ℝ
h : x ≤ y
⊢ x.toNNReal ≤ y.toNNReal

tactic: exact toNNReal_le_toNNReal h
state_before: x y : ℝ
h : x ≤ y
⊢ x.toNNReal ≤ y.toNNReal
state_after: no goals
Theorem: MeasureTheory.lintegral_const_mul''
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: have A : ∫⁻ a, f a ∂μ = ∫⁻ a, hf.mk f a ∂μ := lintegral_congr_ae hf.ae_eq_mk
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ

tactic: have B : ∫⁻ a, r * f a ∂μ = ∫⁻ a, r * hf.mk f a ∂μ :=
  lintegral_congr_ae (EventuallyEq.fun_comp hf.ae_eq_mk _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
B : ∫⁻ (a : α), r * f a ∂μ = ∫⁻ (a : α), r * AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ

tactic: rw [A, B, lintegral_const_mul _ hf.measurable_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
B : ∫⁻ (a : α), r * f a ∂μ = ∫⁻ (a : α), r * AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ
state_after: no goals
Theorem: Encodable.encode_injective
File: Mathlib/Logic/Encodable/Basic.lean

tactic: rw [← encodek, e, encodek]
state_before: α : Type u_1
β : Type u_2
inst✝ : Encodable α
x y : α
e : encode x = encode y
⊢ some x = some y
state_after: no goals
Theorem: Ordinal.add_lt_add_iff_left'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← not_le, ← not_le, add_le_add_iff_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
⊢ a + b < a + c ↔ b < c
state_after: no goals
Theorem: monovaryOn_iff_forall_mul_nonneg
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp only [smul_eq_mul, monovaryOn_iff_forall_smul_nonneg]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ MonovaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → 0 ≤ (f j - f i) * (g j - g i)
state_after: no goals