tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.VectorMeasure.of_add_of_diff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [← of_union (@Set.disjoint_sdiff_right _ A B) hA (hB.diff hA), Set.union_diff_cancel h]
state_before: α : Type u_1
β : Type ?u.23713
m : MeasurableSpace α
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
hA : MeasurableSet A
hB : MeasurableSet B
h : A ⊆ B
⊢ ↑v A + ↑v (B \ A) = ↑v B
Theorem: Ultrafilter.ofComapInfPrincipal_mem
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: let f := Filter.comap m g ⊓ 𝓟 s
state_before: α : Type u
β : Type v
γ : Type ?u.55399
m : α → β
s : Set α
g : Ultrafilter β
h : m '' s ∈ g
⊢ s ∈ ofComapInfPrincipal h

tactic: haveI : f.NeBot := comap_inf_principal_neBot_of_image_mem h
state_before: α : Type u
β : Type v
γ : Type ?u.55399
m : α → β
s : Set α
g : Ultrafilter β
h : m '' s ∈ g
f : Filter α := Filter.comap m ↑g ⊓ 𝓟 s
⊢ s ∈ ofComapInfPrincipal h

tactic: have : s ∈ f := mem_inf_of_right (mem_principal_self s)
state_before: α : Type u
β : Type v
γ : Type ?u.55399
m : α → β
s : Set α
g : Ultrafilter β
h : m '' s ∈ g
f : Filter α := Filter.comap m ↑g ⊓ 𝓟 s
this : NeBot f
⊢ s ∈ ofComapInfPrincipal h

tactic: exact le_def.mp (of_le _) s this
state_before: α : Type u
β : Type v
γ : Type ?u.55399
m : α → β
s : Set α
g : Ultrafilter β
h : m '' s ∈ g
f : Filter α := Filter.comap m ↑g ⊓ 𝓟 s
this✝ : NeBot f
this : s ∈ f
⊢ s ∈ ofComapInfPrincipal h
Theorem: MeasureTheory.Measure.InnerRegular.measure_eq_iSup
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: refine'
  le_antisymm (le_of_forall_lt fun r hr => _) (iSup₂_le fun K hK => iSup_le fun _ => μ.mono hK)
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : InnerRegular μ p q
hU : q U
⊢ ↑↑μ U = ⨆ (K : Set α) (_ : K ⊆ U) (_ : p K), ↑↑μ K

tactic: simpa only [lt_iSup_iff, exists_prop] using H hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : InnerRegular μ p q
hU : q U
r : ℝ≥0∞
hr : r < ↑↑μ U
⊢ r < ⨆ (K : Set α) (_ : K ⊆ U) (_ : p K), ↑↑μ K
Theorem: Int.lt_add_of_pos_right
File: Std/Data/Int/Lemmas.lean

tactic: have : a + 0 < a + b := Int.add_lt_add_left h a
state_before: a b : Int
h : 0 < b
⊢ a < a + b

tactic: rwa [Int.add_zero] at this
state_before: a b : Int
h : 0 < b
this : a + 0 < a + b
⊢ a < a + b
Theorem: Nat.ceil_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← ceil_le, ← not_le, ← ceil_le, not_le,
  tsub_lt_iff_right (Nat.add_one_le_iff.2 (pos_iff_ne_zero.2 hn)), Nat.lt_add_one_iff,
  le_antisymm_iff, and_comm]
state_before: F : Type ?u.57635
α : Type u_1
β : Type ?u.57641
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
⊢ ⌈a⌉₊ = n ↔ ↑(n - 1) < a ∧ a ≤ ↑n
Theorem: OnePoint.not_continuous_cofiniteTopology_of_symm
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: inhabit X
state_before: X : Type u_1
inst✝² : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝¹ : Infinite X
inst✝ : DiscreteTopology X
⊢ ¬Continuous ↑CofiniteTopology.of.symm

tactic: simp only [continuous_iff_continuousAt, ContinuousAt, not_forall]
state_before: X : Type u_1
inst✝² : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝¹ : Infinite X
inst✝ : DiscreteTopology X
inhabited_h : Inhabited X
⊢ ¬Continuous ↑CofiniteTopology.of.symm

tactic: use CofiniteTopology.of ↑(default : X)
state_before: X : Type u_1
inst✝² : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝¹ : Infinite X
inst✝ : DiscreteTopology X
inhabited_h : Inhabited X
⊢ ∃ x, ¬Tendsto (↑CofiniteTopology.of.symm) (𝓝 x) (𝓝 (↑CofiniteTopology.of.symm x))

tactic: simpa [nhds_coe_eq, nhds_discrete, CofiniteTopology.nhds_eq] using
  (finite_singleton ((default : X) : OnePoint X)).infinite_compl
state_before: X : Type u_1
inst✝² : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
inst✝¹ : Infinite X
inst✝ : DiscreteTopology X
inhabited_h : Inhabited X
⊢ ¬Tendsto (↑CofiniteTopology.of.symm) (𝓝 (↑CofiniteTopology.of ↑default))
      (𝓝 (↑CofiniteTopology.of.symm (↑CofiniteTopology.of ↑default)))
Theorem: Path.Homotopy.transAssocReparamAux_one
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: simp [transAssocReparamAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transAssocReparamAux 1 = 1

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ (if 1 ≤ 4⁻¹ then 2 else if 1 ≤ 2⁻¹ then 1 + 4⁻¹ else 2⁻¹ * (1 + 1)) = 1
Theorem: List.foldl_fixed'
File: Mathlib/Data/List/Basic.lean

tactic: rw [foldl_cons, hf b, foldl_fixed' hf l]
state_before: ι : Type ?u.230724
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → α
a : α
hf : ∀ (b : β), f a b = a
b : β
l : List β
⊢ foldl f a (b :: l) = a
Theorem: Substring.Valid.toString_extract
File: Std/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h₁⟩ := h₁.validFor
state_before: b e : Pos
x✝ : Substring
h₁ : Valid x✝
h₂ : Valid { str := toString x✝, startPos := b, stopPos := e }
⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e

tactic: rw [h₁.toString] at h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
h₂ : Valid { str := toString x✝, startPos := b, stopPos := e }
l m r : List Char
h₁ : ValidFor l m r x✝
⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e

tactic: let ⟨ml, mm, mr, h₂⟩ := h₂.validFor
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e

tactic: have ⟨l', r', h₃⟩ := h₁.extract h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e

tactic: rw [h₃.toString, h₁.toString, ← h₂.toString, toString]
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
l' r' : List Char
h₃ : ValidFor l' mm r' (Substring.extract x✝ b e)
⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e
Theorem: LocalHomeomorph.continuousOn_extend
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: refine' I.continuous.comp_continuousOn _
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.135524
M' : Type ?u.135527
H' : Type ?u.135530
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ ContinuousOn (↑(extend f I)) (extend f I).source

tactic: rw [extend_source]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.135524
M' : Type ?u.135527
H' : Type ?u.135530
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ ContinuousOn (fun x => ↑(LocalEquiv.symm (LocalEquiv.restr (LocalEquiv.symm f.toLocalEquiv) I.source)) x)
    (extend f I).source

tactic: exact f.continuousOn
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.135524
M' : Type ?u.135527
H' : Type ?u.135530
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ ContinuousOn (fun x => ↑(LocalEquiv.symm (LocalEquiv.restr (LocalEquiv.symm f.toLocalEquiv) I.source)) x) f.source
Theorem: Filter.Tendsto.atTop_mul
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: refine' tendsto_atTop_mono' _ _ (hf.atTop_mul_const (half_pos hC))
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atTop

tactic: filter_upwards [hg.eventually (lt_mem_nhds (half_lt_self hC)), hf.eventually_ge_atTop 0]
  with x hg hf using mul_le_mul_of_nonneg_left hg.le hf
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ (fun x => f x * (C / 2)) ≤ᶠ[l] fun x => f x * g x
Theorem: measurableSet_iSup_of_mem_piiUnionInter
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rcases ht with ⟨pt, hpt, ft, ht_m, rfl⟩
state_before: α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
t : Set α
ht : t ∈ piiUnionInter (fun n => {s | MeasurableSet s}) S
⊢ MeasurableSet t

tactic: refine' pt.measurableSet_biInter fun i hi => _
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
⊢ MeasurableSet (⋂ (x : ι) (_ : x ∈ pt), ft x)

tactic: suffices h_le : m i ≤ ⨆ i ∈ S, m i
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ MeasurableSet (ft i)

tactic: exact h_le (ft i) (ht_m i hi)
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
h_le : m i ≤ ⨆ (i : ι) (_ : i ∈ S), m i
⊢ MeasurableSet (ft i)

case h_le
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ m i ≤ ⨆ (i : ι) (_ : i ∈ S), m i

tactic: have hi' : i ∈ S := hpt hi
state_before: case h_le
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
⊢ m i ≤ ⨆ (i : ι) (_ : i ∈ S), m i

tactic: exact le_iSup₂ (f := fun i (_ : i ∈ S) => m i) i hi'
state_before: case h_le
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
pt : Finset ι
hpt : ↑pt ⊆ S
ft : ι → Set α
ht_m : ∀ (x : ι), x ∈ pt → ft x ∈ (fun n => {s | MeasurableSet s}) x
i : ι
hi : i ∈ pt
hi' : i ∈ S
⊢ m i ≤ ⨆ (i : ι) (_ : i ∈ S), m i
Theorem: Nat.pow_pred_clog_lt_self
File: Mathlib/Data/Nat/Log.lean

tactic: rw [← not_le, le_pow_iff_clog_le hb, not_le]
state_before: b : ℕ
hb : 1 < b
x : ℕ
hx : 1 < x
⊢ b ^ pred (clog b x) < x

tactic: exact pred_lt (clog_pos hb hx).ne'
state_before: b : ℕ
hb : 1 < b
x : ℕ
hx : 1 < x
⊢ pred (clog b x) < clog b x
Theorem: Finset.bind_toFinset
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [Multiset.mem_toFinset, mem_biUnion, Multiset.mem_bind, exists_prop]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.516416
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq α
s : Multiset α
t : α → Multiset β
x : β
⊢ x ∈ toFinset (Multiset.bind s t) ↔ x ∈ Finset.biUnion (toFinset s) fun a => toFinset (t a)
Theorem: ENNReal.rpow_eq_top_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [ENNReal.rpow_eq_top_iff]
state_before: x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
⊢ x ^ y = ⊤ → x = ⊤

tactic: rintro (h|h)
state_before: x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
⊢ x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y → x = ⊤

tactic: exfalso
state_before: case inl
x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
h : x = 0 ∧ y < 0
⊢ x = ⊤

tactic: rw [lt_iff_not_ge] at h
state_before: case inl.h
x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
h : x = 0 ∧ y < 0
⊢ False

tactic: exact h.right hy0
state_before: case inl.h
x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
h : x = 0 ∧ ¬y ≥ 0
⊢ False

tactic: exact h.left
state_before: case inr
x : ℝ≥0∞
y : ℝ
hy0 : 0 ≤ y
h : x = ⊤ ∧ 0 < y
⊢ x = ⊤
Theorem: Set.Ico_inter_Ici
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Ici_inter_Iio, ← Ici_inter_Iio, ← Ici_inter_Ici, inter_right_comm]
state_before: α : Type u_1
β : Type ?u.182312
inst✝ : SemilatticeSup α
a b c : α
⊢ Ico a b ∩ Ici c = Ico (a ⊔ c) b
Theorem: Nat.ArithmeticFunction.cardDistinctFactors_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [cardDistinctFactors]
state_before: R : Type ?u.569000
⊢ ↑ω 1 = 0
Theorem: Polynomial.mem_roots_sub_C'
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [mem_roots', IsRoot.def, sub_ne_zero, eval_sub, sub_eq_zero, eval_C]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a x : R
⊢ x ∈ roots (p - ↑C a) ↔ p ≠ ↑C a ∧ eval x p = a
Theorem: RatFunc.num_div'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [num, numDenom_div _ hq]
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ num (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) =
    ↑C (leadingCoeff (q / gcd p q))⁻¹ * (p / gcd p q)
Theorem: UniformCauchySeqOnFilter.mono_right
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter α
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p ×ˢ p) ×ˢ p'', (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u
⊢ ∀ (x : (ι × ι) × α), (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u → (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u
Theorem: LipschitzWith.lipschitzWith_compLp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [dist_eq_norm, norm_compLp_sub_le]
state_before: α : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.2832703
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
g✝ : E → F
c : ℝ≥0
inst✝ : Fact (1 ≤ p)
hg : LipschitzWith c g✝
g0 : g✝ 0 = 0
f g : { x // x ∈ Lp E p }
⊢ dist (compLp hg g0 f) (compLp hg g0 g) ≤ ↑c * dist f g
Theorem: algebraicIndependent_empty_type
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: rw [algebraicIndependent_empty_type_iff]
state_before: ι : Type u_1
ι' : Type ?u.1411198
R : Type ?u.1411201
K : Type u_3
A : Type u_2
A' : Type ?u.1411210
A'' : Type ?u.1411213
V : Type u
V' : Type ?u.1411218
x : ι → A
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : CommRing A'
inst✝⁷ : CommRing A''
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R A'
inst✝⁴ : Algebra R A''
a b : R
inst✝³ : Field K
inst✝² : Algebra K A
inst✝¹ : IsEmpty ι
inst✝ : Nontrivial A
⊢ AlgebraicIndependent K x

tactic: exact RingHom.injective _
state_before: ι : Type u_1
ι' : Type ?u.1411198
R : Type ?u.1411201
K : Type u_3
A : Type u_2
A' : Type ?u.1411210
A'' : Type ?u.1411213
V : Type u
V' : Type ?u.1411218
x : ι → A
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : CommRing A'
inst✝⁷ : CommRing A''
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R A'
inst✝⁴ : Algebra R A''
a b : R
inst✝³ : Field K
inst✝² : Algebra K A
inst✝¹ : IsEmpty ι
inst✝ : Nontrivial A
⊢ Injective ↑(algebraMap K A)
Theorem: Nat.factorial_mul_pow_le_factorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: simp
state_before: m✝ n m : ℕ
⊢ m ! * succ m ^ 0 ≤ (m + 0)!

tactic: rw [← add_assoc, ← Nat.succ_eq_add_one (m + n), Nat.factorial_succ, pow_succ',
    mul_comm (_ + 1), mul_comm (succ m), ← mul_assoc]
state_before: m✝ n✝ m n : ℕ
⊢ m ! * succ m ^ (n + 1) ≤ (m + (n + 1))!

tactic: exact
  mul_le_mul factorial_mul_pow_le_factorial (Nat.succ_le_succ (Nat.le_add_right _ _))
    (Nat.zero_le _) (Nat.zero_le _)
state_before: m✝ n✝ m n : ℕ
⊢ m ! * succ m ^ n * succ m ≤ (m + n)! * (m + n + 1)
Theorem: Real.one_le_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simp only [_root_.abs_zero, _root_.abs_nonneg]
state_before: x✝ y z x : ℝ
⊢ abs 0 ≤ abs x
Theorem: Set.image_const_sub_Ioi
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a - x) '' Ioi b = Iio (a - b)

tactic: dsimp [Function.comp] at this
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioi b = Iio (a - b)

tactic: simp [sub_eq_add_neg, this, add_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ioi b = Iio (a - b)
Theorem: Real.rpow_sum_le_const_mul_sum_rpow
File: Mathlib/Analysis/MeanInequalities.lean

tactic: have :=
  NNReal.coe_le_coe.2
    (NNReal.rpow_sum_le_const_mul_sum_rpow s (fun i => ⟨_, abs_nonneg (f i)⟩) hp)
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
⊢ (∑ i in s, abs (f i)) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, abs (f i) ^ p

tactic: push_cast at this
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
this :
  ↑((∑ i in s, (fun i => { val := abs (f i), property := (_ : 0 ≤ abs (f i)) }) i) ^ p) ≤
    ↑(↑(card s) ^ (p - 1) * ∑ i in s, (fun i => { val := abs (f i), property := (_ : 0 ≤ abs (f i)) }) i ^ p)
⊢ (∑ i in s, abs (f i)) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, abs (f i) ^ p

tactic: exact this
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
this : (∑ x in s, abs (f x)) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ x in s, abs (f x) ^ p
⊢ (∑ i in s, abs (f i)) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, abs (f i) ^ p
Theorem: Set.image_injective
File: Mathlib/Data/Set/Image.lean

tactic: refine' ⟨fun h x x' hx => _, Injective.image_injective⟩
state_before: α : Type u
β : Type v
f : α → β
⊢ Injective (image f) ↔ Injective f

tactic: rw [← singleton_eq_singleton_iff]
state_before: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ x = x'

tactic: apply h
state_before: α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ {x} = {x'}

tactic: rw [image_singleton, image_singleton, hx]
state_before: case a
α : Type u
β : Type v
f : α → β
h : Injective (image f)
x x' : α
hx : f x = f x'
⊢ f '' {x} = f '' {x'}
Theorem: Polynomial.natDegree_C_mul_eq_of_mul_eq_one
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: nth_rw 1 [← one_mul p]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
ai : R
au : ai * a = 1
⊢ natDegree p = natDegree (1 * p)

tactic: rw [← C_1, ← au, RingHom.map_mul, ← mul_assoc]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
ai : R
au : ai * a = 1
⊢ natDegree (1 * p) = natDegree (↑C ai * (↑C a * p))
Theorem: abv_sum_le_sum_abv
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [abv_zero abv]
state_before: α : Type u_2
β : Type u_3
inst✝² : LinearOrderedField α
abv : β → α
inst✝¹ : Semiring β
inst✝ : IsAbsoluteValue abv
γ : Type u_1
f : γ → β
s : Finset γ
this : DecidableEq γ
⊢ abv (∑ k in ∅, f k) ≤ ∑ k in ∅, abv (f k)

tactic: rw [sum_insert has, sum_insert has]
state_before: α : Type u_2
β : Type u_3
inst✝² : LinearOrderedField α
abv : β → α
inst✝¹ : Semiring β
inst✝ : IsAbsoluteValue abv
γ : Type u_1
f : γ → β
s✝ : Finset γ
this : DecidableEq γ
a : γ
s : Finset γ
has : ¬a ∈ s
ih : abv (∑ k in s, f k) ≤ ∑ k in s, abv (f k)
⊢ abv (∑ k in insert a s, f k) ≤ ∑ k in insert a s, abv (f k)

tactic: exact le_trans (abv_add abv _ _) (add_le_add_left ih _)
state_before: α : Type u_2
β : Type u_3
inst✝² : LinearOrderedField α
abv : β → α
inst✝¹ : Semiring β
inst✝ : IsAbsoluteValue abv
γ : Type u_1
f : γ → β
s✝ : Finset γ
this : DecidableEq γ
a : γ
s : Finset γ
has : ¬a ∈ s
ih : abv (∑ k in s, f k) ≤ ∑ k in s, abv (f k)
⊢ abv (f a + ∑ x in s, f x) ≤ abv (f a) + ∑ x in s, abv (f x)
Theorem: ContinuousMap.liftCover_coe'
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: delta liftCover'
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64319
δ : Type ?u.64322
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
ι : Type ?u.64355
S : ι → Set α
φ : (i : ι) → C(↑(S i), β)
hφ :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    ↑(φ i) { val := x, property := hxi } = ↑(φ j) { val := x, property := hxj }
hS : ∀ (x : α), ∃ i, S i ∈ nhds x
A : Set (Set α)
F : (s : Set α) → s ∈ A → C(↑s, β)
hF :
  ∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
    ↑(F s hs) { val := x, property := hxi } = ↑(F t ht) { val := x, property := hxj }
hA : ∀ (x : α), ∃ i, i ∈ A ∧ i ∈ nhds x
s : Set α
hs : s ∈ A
x : ↑s
x' : ↑↑{ val := s, property := hs } := x
⊢ ↑(liftCover' A F hF hA) ↑x = ↑(F s hs) x

tactic: exact liftCover_coe x'
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64319
δ : Type ?u.64322
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
ι : Type ?u.64355
S : ι → Set α
φ : (i : ι) → C(↑(S i), β)
hφ :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    ↑(φ i) { val := x, property := hxi } = ↑(φ j) { val := x, property := hxj }
hS : ∀ (x : α), ∃ i, S i ∈ nhds x
A : Set (Set α)
F : (s : Set α) → s ∈ A → C(↑s, β)
hF :
  ∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
    ↑(F s hs) { val := x, property := hxi } = ↑(F t ht) { val := x, property := hxj }
hA : ∀ (x : α), ∃ i, i ∈ A ∧ i ∈ nhds x
s : Set α
hs : s ∈ A
x : ↑s
x' : ↑↑{ val := s, property := hs } := x
⊢ ↑(let S := Subtype.val;
        let F_1 := fun i => F ↑i (_ : ↑i ∈ A);
        liftCover S F_1
          (_ :
            ∀ (i j : ↑A) (x : α) (hxi : x ∈ ↑i) (hxj : x ∈ ↑j),
              ↑(F ↑i (_ : ↑i ∈ A)) { val := x, property := hxi } = ↑(F ↑j (_ : ↑j ∈ A)) { val := x, property := hxj })
          (_ : ∀ (x : α), ∃ i, ↑i ∈ nhds x))
      ↑x =
    ↑(F s hs) x
Theorem: MeasureTheory.quasiMeasurePreserving_inv_of_right_invariant
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: rw [← μ.inv_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ QuasiMeasurePreserving Inv.inv

tactic: exact
  (quasiMeasurePreserving_inv μ.inv).mono (inv_absolutelyContinuous μ.inv)
    (absolutelyContinuous_inv μ.inv)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ QuasiMeasurePreserving Inv.inv