tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Lp.tendsto_Lp_iff_tendsto_ℒp'
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [tendsto_iff_dist_tendsto_zero]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8121841
G : Type ?u.8121844
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : { x // x ∈ Lp E p }
⊢ Tendsto f fi (𝓝 f_lim) ↔ Tendsto (fun n => snorm (↑↑(f n) - ↑↑f_lim) p μ) fi (𝓝 0)

tactic: simp_rw [dist_def]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8121841
G : Type ?u.8121844
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : { x // x ∈ Lp E p }
⊢ Tendsto (fun b => dist (f b) f_lim) fi (𝓝 0) ↔ Tendsto (fun n => snorm (↑↑(f n) - ↑↑f_lim) p μ) fi (𝓝 0)

tactic: rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff (fun n => ?_) ENNReal.zero_ne_top]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8121841
G : Type ?u.8121844
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : { x // x ∈ Lp E p }
⊢ Tendsto (fun b => ENNReal.toReal (snorm (↑↑(f b) - ↑↑f_lim) p μ)) fi (𝓝 0) ↔
    Tendsto (fun n => snorm (↑↑(f n) - ↑↑f_lim) p μ) fi (𝓝 0)

tactic: rw [snorm_congr_ae (Lp.coeFn_sub _ _).symm]
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8121841
G : Type ?u.8121844
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : { x // x ∈ Lp E p }
n : ι
⊢ snorm (↑↑(f n) - ↑↑f_lim) p μ ≠ ⊤

tactic: exact Lp.snorm_ne_top _
state_before: α : Type u_2
E : Type u_3
F : Type ?u.8121841
G : Type ?u.8121844
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
ι : Type u_1
fi : Filter ι
inst✝ : Fact (1 ≤ p)
f : ι → { x // x ∈ Lp E p }
f_lim : { x // x ∈ Lp E p }
n : ι
⊢ snorm (↑↑(f n - f_lim)) p μ ≠ ⊤
Theorem: dist_self_mul_right
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← dist_one_left, ← dist_mul_left a 1 b, mul_one]
state_before: 𝓕 : Type ?u.636975
𝕜 : Type ?u.636978
α : Type ?u.636981
ι : Type ?u.636984
κ : Type ?u.636987
E : Type u_1
F : Type ?u.636993
G : Type ?u.636996
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a (a * b) = ‖b‖
Theorem: MeasureTheory.setToFun_congr_measure
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1651275
G : Type ?u.1651278
𝕜 : Type ?u.1651281
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
c c' : ℝ≥0∞
hc : c ≠ ⊤
hc' : c' ≠ ⊤
hμ_le : μ ≤ c • μ'
hμ'_le : μ' ≤ c' • μ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ' T C'
f : α → E
⊢ setToFun μ T hT f = setToFun μ' T hT' f

tactic: exact setToFun_congr_measure_of_integrable c' hc' hμ'_le hT hT' f hf
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1651275
G : Type ?u.1651278
𝕜 : Type ?u.1651281
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
c c' : ℝ≥0∞
hc : c ≠ ⊤
hc' : c' ≠ ⊤
hμ_le : μ ≤ c • μ'
hμ'_le : μ' ≤ c' • μ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ' T C'
f : α → E
hf : Integrable f
⊢ setToFun μ T hT f = setToFun μ' T hT' f

tactic: have h_int : ∀ g : α → E, ¬Integrable g μ → ¬Integrable g μ' := fun g =>
  mt fun h => h.of_measure_le_smul _ hc hμ_le
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1651275
G : Type ?u.1651278
𝕜 : Type ?u.1651281
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
c c' : ℝ≥0∞
hc : c ≠ ⊤
hc' : c' ≠ ⊤
hμ_le : μ ≤ c • μ'
hμ'_le : μ' ≤ c' • μ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ' T C'
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T hT f = setToFun μ' T hT' f

tactic: simp_rw [setToFun_undef _ hf, setToFun_undef _ (h_int f hf)]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1651275
G : Type ?u.1651278
𝕜 : Type ?u.1651281
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
c c' : ℝ≥0∞
hc : c ≠ ⊤
hc' : c' ≠ ⊤
hμ_le : μ ≤ c • μ'
hμ'_le : μ' ≤ c' • μ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ' T C'
f : α → E
hf : ¬Integrable f
h_int : ∀ (g : α → E), ¬Integrable g → ¬Integrable g
⊢ setToFun μ T hT f = setToFun μ' T hT' f
Theorem: MeasureTheory.memℒp_const_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [← snorm_const_lt_top_iff hp_ne_zero hp_ne_top]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1273342
G : Type ?u.1273345
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => c) p ↔ c = 0 ∨ ↑↑μ Set.univ < ⊤

tactic: exact ⟨fun h => h.2, fun h => ⟨aestronglyMeasurable_const, h⟩⟩
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1273342
G : Type ?u.1273345
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => c) p ↔ snorm (fun x => c) p μ < ⊤
Theorem: Set.star_subset
File: Mathlib/Algebra/Star/Pointwise.lean

tactic: rw [← star_subset_star, star_star]
state_before: α : Type u_1
s✝ t✝ : Set α
a : α
inst✝ : InvolutiveStar α
s t : Set α
⊢ s⋆ ⊆ t ↔ s ⊆ t⋆
Theorem: Set.pairwise_insert
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [insert_eq, pairwise_union, pairwise_singleton, true_and_iff, mem_singleton_iff,
  forall_eq]
state_before: α : Type u_1
β : Type ?u.10052
γ : Type ?u.10055
ι : Type ?u.10058
ι' : Type ?u.10061
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
⊢ Set.Pairwise (insert a s) r ↔ Set.Pairwise s r ∧ ∀ (b : α), b ∈ s → a ≠ b → r a b ∧ r b a
Theorem: List.Ico.filter_lt_of_succ_bot
File: Mathlib/Data/List/Intervals.lean

tactic: have r : min m (n + 1) = n + 1 := (@inf_eq_right _ _ m (n + 1)).mpr hnm
state_before: n m : ℕ
hnm : n < m
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]

tactic: simp [filter_lt n m (n + 1), r]
state_before: n m : ℕ
hnm : n < m
r : min m (n + 1) = n + 1
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
Theorem: Int.sub_nonpos_of_le
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_le_add_right h (-b)
state_before: a b : Int
h : a ≤ b
⊢ a - b ≤ 0

tactic: rwa [Int.add_right_neg] at h
state_before: a b : Int
h✝ : a ≤ b
h : a + -b ≤ b + -b
⊢ a - b ≤ 0
Theorem: SemiconjBy.pow_right
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: induction' n with n ih
state_before: M : Type u_1
inst✝ : Monoid M
a x y : M
h : SemiconjBy a x y
n : ℕ
⊢ SemiconjBy a (x ^ n) (y ^ n)

tactic: rw [pow_zero, pow_zero]
state_before: case zero
M : Type u_1
inst✝ : Monoid M
a x y : M
h : SemiconjBy a x y
⊢ SemiconjBy a (x ^ Nat.zero) (y ^ Nat.zero)

tactic: exact SemiconjBy.one_right _
state_before: case zero
M : Type u_1
inst✝ : Monoid M
a x y : M
h : SemiconjBy a x y
⊢ SemiconjBy a 1 1

tactic: rw [pow_succ, pow_succ]
state_before: case succ
M : Type u_1
inst✝ : Monoid M
a x y : M
h : SemiconjBy a x y
n : ℕ
ih : SemiconjBy a (x ^ n) (y ^ n)
⊢ SemiconjBy a (x ^ Nat.succ n) (y ^ Nat.succ n)

tactic: exact h.mul_right ih
state_before: case succ
M : Type u_1
inst✝ : Monoid M
a x y : M
h : SemiconjBy a x y
n : ℕ
ih : SemiconjBy a (x ^ n) (y ^ n)
⊢ SemiconjBy a (x * x ^ n) (y * y ^ n)
Theorem: Nat.ArithmeticFunction.vonMangoldt_nonneg
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: rw [vonMangoldt_apply]
state_before: n : ℕ
⊢ 0 ≤ ↑Λ n

tactic: split_ifs
state_before: n : ℕ
⊢ 0 ≤ if IsPrimePow n then Real.log ↑(minFac n) else 0

tactic: rfl
state_before: case inr
n : ℕ
h✝ : ¬IsPrimePow n
⊢ 0 ≤ 0

tactic: exact Real.log_nonneg (one_le_cast.2 (Nat.minFac_pos n))
state_before: case inl
n : ℕ
h✝ : IsPrimePow n
⊢ 0 ≤ Real.log ↑(minFac n)
Theorem: MulChar.IsQuadratic.inv
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: ext x
state_before: R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
⊢ χ⁻¹ = χ

tactic: rw [inv_apply_eq_inv]
state_before: case h
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
⊢ ↑χ⁻¹ ↑x = ↑χ ↑x

tactic: rcases hχ x with (h₀ | h₁ | h₂)
state_before: case h
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
⊢ Ring.inverse (↑χ ↑x) = ↑χ ↑x

tactic: rw [h₀, Ring.inverse_zero]
state_before: case h.inl
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₀ : ↑χ ↑x = 0
⊢ Ring.inverse (↑χ ↑x) = ↑χ ↑x

tactic: rw [h₁, Ring.inverse_one]
state_before: case h.inr.inl
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₁ : ↑χ ↑x = 1
⊢ Ring.inverse (↑χ ↑x) = ↑χ ↑x

tactic: have : (-1 : R') = (-1 : R'ˣ) := by rw [Units.val_neg, Units.val_one]
state_before: case h.inr.inr
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₂ : ↑χ ↑x = -1
⊢ Ring.inverse (↑χ ↑x) = ↑χ ↑x

tactic: rw [h₂, this, Ring.inverse_unit (-1 : R'ˣ)]
state_before: case h.inr.inr
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₂ : ↑χ ↑x = -1
this : -1 = ↑(-1)
⊢ Ring.inverse (↑χ ↑x) = ↑χ ↑x

tactic: rfl
state_before: case h.inr.inr
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₂ : ↑χ ↑x = -1
this : -1 = ↑(-1)
⊢ ↑(-1)⁻¹ = ↑(-1)

tactic: rw [Units.val_neg, Units.val_one]
state_before: R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
x : Rˣ
h₂ : ↑χ ↑x = -1
⊢ -1 = ↑(-1)
Theorem: Finset.is_glb_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← mem_coe]
state_before: F : Type ?u.408857
α : Type u_1
β : Type ?u.408863
γ : Type ?u.408866
ι : Type ?u.408869
κ : Type ?u.408872
inst✝ : LinearOrder α
i : α
s : Finset α
his : IsGLB (↑s) i
hs : Finset.Nonempty s
⊢ i ∈ s

tactic: exact ((is_glb_iff_is_least i s hs).mp his).1
state_before: F : Type ?u.408857
α : Type u_1
β : Type ?u.408863
γ : Type ?u.408866
ι : Type ?u.408869
κ : Type ?u.408872
inst✝ : LinearOrder α
i : α
s : Finset α
his : IsGLB (↑s) i
hs : Finset.Nonempty s
⊢ i ∈ ↑s
Theorem: MeasurableEmbedding.restrict_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [hf.map_apply, ht, hf.measurable ht]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1222190
δ : Type ?u.1222193
ι : Type ?u.1222196
R : Type ?u.1222199
R' : Type ?u.1222202
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : MeasureTheory.Measure α
s t : Set β
ht : MeasurableSet t
⊢ ↑↑(Measure.restrict (Measure.map f μ) s) t = ↑↑(Measure.map f (Measure.restrict μ (f ⁻¹' s))) t
Theorem: FreeSemigroup.lift_of_mul
File: Mathlib/Algebra/Free.lean

tactic: rw [map_mul, lift_of]
state_before: α : Type u
β : Type v
inst✝ : Semigroup β
f : α → β
x : α
y : FreeSemigroup α
⊢ ↑(↑lift f) (of x * y) = f x * ↑(↑lift f) y
Theorem: List.map_filterMap
File: Std/Data/List/Lemmas.lean

tactic: simp only [← filterMap_eq_map, filterMap_filterMap, Option.map_eq_bind]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
g : β → γ
l : List α
⊢ map g (filterMap f l) = filterMap (fun x => Option.map g (f x)) l
Theorem: IsGreatest.insert
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [insert_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s : Set γ
hs : IsGreatest s b
⊢ IsGreatest (Insert.insert a s) (max a b)

tactic: exact isGreatest_singleton.union hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s : Set γ
hs : IsGreatest s b
⊢ IsGreatest ({a} ∪ s) (max a b)
Theorem: List.max_le_of_forall_le
File: Mathlib/Data/List/MinMax.lean

tactic: induction' l with y l IH
state_before: α : Type u_1
β : Type ?u.111970
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a : α
h : ∀ (x : α), x ∈ l → x ≤ a
⊢ foldr max ⊥ l ≤ a

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.111970
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a : α
h✝ : ∀ (x : α), x ∈ l → x ≤ a
h : ∀ (x : α), x ∈ [] → x ≤ a
⊢ foldr max ⊥ [] ≤ a

tactic: simpa [h y (mem_cons_self _ _)] using IH fun x hx => h x <| mem_cons_of_mem _ hx
state_before: case cons
α : Type u_1
β : Type ?u.111970
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝¹ l✝ : List α
a : α
h✝ : ∀ (x : α), x ∈ l✝ → x ≤ a
y : α
l : List α
IH : (∀ (x : α), x ∈ l → x ≤ a) → foldr max ⊥ l ≤ a
h : ∀ (x : α), x ∈ y :: l → x ≤ a
⊢ foldr max ⊥ (y :: l) ≤ a
Theorem: Filter.map_comap_of_surjective
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [hf.range_eq, univ_mem]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.258330
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
hf : Surjective f
l : Filter β
⊢ range f ∈ l
Theorem: Set.Iic_diff_Iic
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [diff_eq, compl_Iic, inter_comm, Ioi_inter_Iic]
state_before: α : Type u_1
β : Type ?u.62385
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iic b \ Iic a = Ioc a b
Theorem: Submonoid.LocalizationMap.mul_inv
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_inv_right h, mul_assoc, mul_comm _ (f y₂), ← mul_assoc, mul_inv_left h, mul_comm x₂,
  f.map_mul, f.map_mul]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.417122
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
x₁ x₂ : M
y₁ y₂ : { x // x ∈ S }
⊢ ↑f x₁ * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y₁)⁻¹ =
      ↑f x₂ * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y₂)⁻¹ ↔
    ↑f (x₁ * ↑y₂) = ↑f (x₂ * ↑y₁)
Theorem: List.Pairwise.sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: simp only [sublists'_cons, pairwise_append, pairwise_map, mem_sublists', mem_map, exists_imp,
  and_imp]
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
⊢ Pairwise (Lex (swap R)) (List.sublists' (a :: l))

tactic: refine' ⟨H₂.sublists', H₂.sublists'.imp fun l₁ => Lex.cons l₁, _⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
⊢ Pairwise (Lex (swap R)) (List.sublists' l) ∧
    Pairwise (fun a_1 b => Lex (swap R) (a :: a_1) (a :: b)) (List.sublists' l) ∧
      ∀ (a_1 : List α), a_1 <+ l → ∀ (b x : List α), x <+ l → a :: x = b → Lex (swap R) a_1 b

tactic: rintro l₁ sl₁ x l₂ _ rfl
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
⊢ ∀ (a_1 : List α), a_1 <+ l → ∀ (b x : List α), x <+ l → a :: x = b → Lex (swap R) a_1 b

tactic: cases' l₁ with b l₁
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
l₁ : List α
sl₁ : l₁ <+ l
l₂ : List α
a✝ : l₂ <+ l
⊢ Lex (swap R) l₁ (a :: l₂)

tactic: exact Lex.rel (H₁ _ <| sl₁.subset <| mem_cons_self _ _)
state_before: case cons
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
l₂ : List α
a✝ : l₂ <+ l
b : α
l₁ : List α
sl₁ : b :: l₁ <+ l
⊢ Lex (swap R) (b :: l₁) (a :: l₂)

tactic: constructor
state_before: case nil
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
a : α
l : List α
H₁ : ∀ (a' : α), a' ∈ l → R a a'
H₂ : Pairwise R l
l₂ : List α
a✝ : l₂ <+ l
sl₁ : [] <+ l
⊢ Lex (swap R) [] (a :: l₂)
Theorem: aemeasurable_const'
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: rcases eq_or_ne μ 0 with (rfl | hμ)
state_before: ι : Type ?u.3045534
α : Type u_1
β : Type u_2
γ : Type ?u.3045543
δ : Type ?u.3045546
R : Type ?u.3045549
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
h : ∀ᵐ (x : α) (y : α) ∂μ, f x = f y
⊢ AEMeasurable f

tactic: exact aemeasurable_zero_measure
state_before: case inl
ι : Type ?u.3045534
α : Type u_1
β : Type u_2
γ : Type ?u.3045543
δ : Type ?u.3045546
R : Type ?u.3045549
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
ν : MeasureTheory.Measure α
h : ∀ᵐ (x : α) (y : α) ∂0, f x = f y
⊢ AEMeasurable f

tactic: haveI := ae_neBot.2 hμ
state_before: case inr
ι : Type ?u.3045534
α : Type u_1
β : Type u_2
γ : Type ?u.3045543
δ : Type ?u.3045546
R : Type ?u.3045549
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
h : ∀ᵐ (x : α) (y : α) ∂μ, f x = f y
hμ : μ ≠ 0
⊢ AEMeasurable f

tactic: rcases h.exists with ⟨x, hx⟩
state_before: case inr
ι : Type ?u.3045534
α : Type u_1
β : Type u_2
γ : Type ?u.3045543
δ : Type ?u.3045546
R : Type ?u.3045549
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
h : ∀ᵐ (x : α) (y : α) ∂μ, f x = f y
hμ : μ ≠ 0
this : NeBot (ae μ)
⊢ AEMeasurable f

tactic: exact ⟨const α (f x), measurable_const, EventuallyEq.symm hx⟩
state_before: case inr.intro
ι : Type ?u.3045534
α : Type u_1
β : Type u_2
γ : Type ?u.3045543
δ : Type ?u.3045546
R : Type ?u.3045549
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
h : ∀ᵐ (x : α) (y : α) ∂μ, f x = f y
hμ : μ ≠ 0
this : NeBot (ae μ)
x : α
hx : ∀ᵐ (y : α) ∂μ, f x = f y
⊢ AEMeasurable f
Theorem: le_of_inf_le_sup_le
File: Mathlib/Order/Lattice.lean

tactic: rw [sup_inf_right, @sup_comm _ _ x]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
h₁ : x ⊓ z ≤ y ⊓ z
h₂ : x ⊔ z ≤ y ⊔ z
⊢ y ⊓ z ⊔ x = (y ⊔ x) ⊓ (x ⊔ z)
Theorem: smul_one_smul
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [smul_assoc, one_smul]
state_before: M✝ : Type ?u.26534
N✝ : Type ?u.26537
G : Type ?u.26540
A : Type ?u.26543
B : Type ?u.26546
α : Type u_3
β : Type ?u.26552
γ : Type ?u.26555
δ : Type ?u.26558
M : Type u_1
N : Type u_2
inst✝⁴ : Monoid N
inst✝³ : SMul M N
inst✝² : MulAction N α
inst✝¹ : SMul M α
inst✝ : IsScalarTower M N α
x : M
y : α
⊢ (x • 1) • y = x • y
Theorem: Finsupp.erase_ne
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical simp only [erase, coe_mk, h, ite_false]
state_before: α : Type u_1
β : Type ?u.164124
γ : Type ?u.164127
ι : Type ?u.164130
M : Type u_2
M' : Type ?u.164136
N : Type ?u.164139
P : Type ?u.164142
G : Type ?u.164145
H : Type ?u.164148
R : Type ?u.164151
S : Type ?u.164154
inst✝ : Zero M
a a' : α
f : α →₀ M
h : a' ≠ a
⊢ ↑(erase a f) a' = ↑f a'

tactic: simp only [erase, coe_mk, h, ite_false]
state_before: α : Type u_1
β : Type ?u.164124
γ : Type ?u.164127
ι : Type ?u.164130
M : Type u_2
M' : Type ?u.164136
N : Type ?u.164139
P : Type ?u.164142
G : Type ?u.164145
H : Type ?u.164148
R : Type ?u.164151
S : Type ?u.164154
inst✝ : Zero M
a a' : α
f : α →₀ M
h : a' ≠ a
⊢ ↑(erase a f) a' = ↑f a'
Theorem: CFilter.ofEquiv_val
File: Mathlib/Data/Analysis/Filter.lean

tactic: cases F
state_before: α : Type u_3
β : Type ?u.5122
σ : Type u_1
τ : Type u_2
inst✝ : PartialOrder α
F✝ : CFilter α σ
E : σ ≃ τ
F : CFilter α σ
a : τ
⊢ f (ofEquiv E F) a = f F (↑E.symm a)

tactic: rfl
state_before: case mk
α : Type u_3
β : Type ?u.5122
σ : Type u_1
τ : Type u_2
inst✝ : PartialOrder α
F : CFilter α σ
E : σ ≃ τ
a : τ
f✝ : σ → α
pt✝ : σ
inf✝ : σ → σ → σ
inf_le_left✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ a
inf_le_right✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ b
⊢ f (ofEquiv E { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ }) a =
    f { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ } (↑E.symm a)
Theorem: CategoryTheory.IsPushout.inr_isoPushout_hom
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simp [← Iso.eq_comp_inv]
state_before: C : Type u₁
inst✝¹ : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
h : IsPushout f g inl inr
inst✝ : HasPushout f g
⊢ inr ≫ (isoPushout h).hom = pushout.inr
Theorem: nhds_translation_mul_inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x✝ : α
x : G
⊢ 𝓝 (1 * x⁻¹⁻¹) = 𝓝 x
Theorem: List.foldr_eta
File: Mathlib/Data/List/Basic.lean

tactic: simp only [foldr_self_append, append_nil, forall_const]
state_before: ι : Type ?u.232631
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
⊢ ∀ (l : List α), foldr cons [] l = l
Theorem: sub_sq
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: rw [sub_eq_add_neg, add_sq, neg_sq, mul_neg, ← sub_eq_add_neg]
state_before: R : Type u_1
S : Type ?u.128156
M : Type ?u.128159
inst✝ : CommRing R
a b : R
⊢ (a - b) ^ 2 = a ^ 2 - 2 * a * b + b ^ 2