tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.lintegral_max
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: have hm : MeasurableSet { x | f x ≤ g x } := measurableSet_le hf hg
state_before: α : Type u_1
β : Type ?u.1029220
γ : Type ?u.1029223
δ : Type ?u.1029226
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
⊢ (∫⁻ (x : α), max (f x) (g x) ∂μ) = (∫⁻ (x : α) in {x | f x ≤ g x}, g x ∂μ) + ∫⁻ (x : α) in {x | g x < f x}, f x ∂μ

tactic: rw [← lintegral_add_compl (fun x => max (f x) (g x)) hm]
state_before: α : Type u_1
β : Type ?u.1029220
γ : Type ?u.1029223
δ : Type ?u.1029226
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hm : MeasurableSet {x | f x ≤ g x}
⊢ (∫⁻ (x : α), max (f x) (g x) ∂μ) = (∫⁻ (x : α) in {x | f x ≤ g x}, g x ∂μ) + ∫⁻ (x : α) in {x | g x < f x}, f x ∂μ

tactic: simp only [← compl_setOf, ← not_le]
state_before: α : Type u_1
β : Type ?u.1029220
γ : Type ?u.1029223
δ : Type ?u.1029226
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hm : MeasurableSet {x | f x ≤ g x}
⊢ ((∫⁻ (x : α) in {x | f x ≤ g x}, max (f x) (g x) ∂μ) + ∫⁻ (x : α) in {x | f x ≤ g x}ᶜ, max (f x) (g x) ∂μ) =
    (∫⁻ (x : α) in {x | f x ≤ g x}, g x ∂μ) + ∫⁻ (x : α) in {x | g x < f x}, f x ∂μ

tactic: exacts [ae_of_all _ fun x => max_eq_right (a := f x) (b := g x),
  ae_of_all _ fun x (hx : ¬ f x ≤ g x) => max_eq_left (not_le.1 hx).le]
state_before: case refine'_1
α : Type u_1
β : Type ?u.1029220
γ : Type ?u.1029223
δ : Type ?u.1029226
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hm : MeasurableSet {x | f x ≤ g x}
⊢ ∀ᵐ (x : α) ∂μ, x ∈ {x | f x ≤ g x} → max (f x) (g x) = g x

case refine'_2
α : Type u_1
β : Type ?u.1029220
γ : Type ?u.1029223
δ : Type ?u.1029226
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hm : MeasurableSet {x | f x ≤ g x}
⊢ ∀ᵐ (x : α) ∂μ, x ∈ {x | f x ≤ g x}ᶜ → max (f x) (g x) = f x
Theorem: CategoryTheory.GrothendieckTopology.sheafifyMap_sheafifyLift
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: apply J.sheafifyLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ sheafifyMap J η ≫ sheafifyLift J γ hR = sheafifyLift J (η ≫ γ) hR

tactic: rw [← Category.assoc, ← J.toSheafify_naturality, Category.assoc, toSheafify_sheafifyLift]
state_before: case a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ
Theorem: Int.map_floor
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← map_intCast f, hf.le_iff_le]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedRing β
inst✝² : FloorRing α
inst✝¹ : FloorRing β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ↑f
a : α
n : ℤ
⊢ ↑n ≤ ↑f a ↔ ↑n ≤ a
Theorem: padicValRat.div
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [div_eq_mul_inv, padicValRat.mul hq (inv_ne_zero hr), padicValRat.inv r, sub_eq_add_neg]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hq : q ≠ 0
hr : r ≠ 0
⊢ padicValRat p (q / r) = padicValRat p q - padicValRat p r
Theorem: Stirling.tendsto_self_div_two_mul_self_add_one
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: refine' (((tendsto_const_div_atTop_nhds_0_nat 1).const_add (2 : ℝ)).inv₀
  ((add_zero (2 : ℝ)).symm ▸ two_ne_zero)).congr' (eventually_atTop.mpr ⟨1, fun n hn => _⟩)
state_before: ⊢ Tendsto (fun n => ↑n / (2 * ↑n + 1)) atTop (𝓝 (2 + 0)⁻¹)

tactic: rw [add_div' (1 : ℝ) 2 n (cast_ne_zero.mpr (one_le_iff_ne_zero.mp hn)), inv_div]
state_before: n : ℕ
hn : n ≥ 1
⊢ (2 + 1 / ↑n)⁻¹ = (fun n => ↑n / (2 * ↑n + 1)) n
Theorem: Cardinal.eq_aleph'_of_eq_card_ord
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simpa using ho
state_before: o : Ordinal
ho : ord (card o) = o
⊢ ord (aleph' (↑alephIdx.relIso (card o))) = o
Theorem: String.foldl_eq
File: Std/Data/String/Lemmas.lean

tactic: simpa using foldlAux_of_valid f [] s.1 [] a
state_before: α : Type u_1
f : α → Char → α
s : String
a : α
⊢ foldl f a s = List.foldl f a s.data
Theorem: CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
state_before: f g f₁ f₂ : CircleDeg1Lift
h₁ : IsUnit f₁
h₂ : IsUnit f₂
h : τ f₁ = τ f₂
⊢ ∃ F, Semiconj ↑F ↑f₁ ↑f₂

tactic: exact units_semiconj_of_translationNumber_eq h
state_before: case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ↑F ↑↑f₁ ↑↑f₂
Theorem: ProbabilityTheory.kernel.lintegral_piecewise
File: Mathlib/Probability/Kernel/Basic.lean

tactic: simp_rw [piecewise_apply]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1467338
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
⊢ (∫⁻ (b : β), g b ∂↑(piecewise hs κ η) a) = if a ∈ s then ∫⁻ (b : β), g b ∂↑κ a else ∫⁻ (b : β), g b ∂↑η a

tactic: split_ifs <;> rfl
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.1467338
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
⊢ (∫⁻ (b : β), g b ∂if a ∈ s then ↑κ a else ↑η a) = if a ∈ s then ∫⁻ (b : β), g b ∂↑κ a else ∫⁻ (b : β), g b ∂↑η a
Theorem: Set.exists_subset_range_and_iff
File: Mathlib/Data/Set/Image.lean

tactic: rw [← exists_range_iff, range_image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.75177
ι : Sort ?u.75180
ι' : Sort ?u.75183
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∃ s, s ⊆ range f ∧ p s) ↔ ∃ s, p (f '' s)

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.75177
ι : Sort ?u.75180
ι' : Sort ?u.75183
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∃ s, s ⊆ range f ∧ p s) ↔ ∃ a, a ∈ 𝒫 range f ∧ p a
Theorem: measurable_of_measurable_union_cover
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: convert (hs.subtype_image (hc hu)).union (ht.subtype_image (hd hu))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.70127
δ : Type ?u.70130
δ' : Type ?u.70133
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hc : Measurable fun a => f ↑a
hd : Measurable fun a => f ↑a
u : Set β
hu : MeasurableSet u
⊢ MeasurableSet (f ⁻¹' u)

tactic: change f ⁻¹' u = (↑) '' ((↑) ⁻¹' (f ⁻¹' u) : Set s) ∪ (↑) '' ((↑) ⁻¹' (f ⁻¹' u) : Set t)
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type ?u.70127
δ : Type ?u.70130
δ' : Type ?u.70133
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hc : Measurable fun a => f ↑a
hd : Measurable fun a => f ↑a
u : Set β
hu : MeasurableSet u
⊢ f ⁻¹' u = Subtype.val '' ((fun a => f ↑a) ⁻¹' u) ∪ Subtype.val '' ((fun a => f ↑a) ⁻¹' u)

tactic: rw [image_preimage_eq_inter_range, image_preimage_eq_inter_range, Subtype.range_coe,
  Subtype.range_coe, ← inter_distrib_left, univ_subset_iff.1 h, inter_univ]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type ?u.70127
δ : Type ?u.70130
δ' : Type ?u.70133
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hc : Measurable fun a => f ↑a
hd : Measurable fun a => f ↑a
u : Set β
hu : MeasurableSet u
⊢ f ⁻¹' u = Subtype.val '' (Subtype.val ⁻¹' (f ⁻¹' u)) ∪ Subtype.val '' (Subtype.val ⁻¹' (f ⁻¹' u))
Theorem: Equiv.Perm.isCycleOn_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [IsCycleOn, Set.bijOn_id, Set.Subsingleton]
state_before: ι : Type ?u.1635260
α : Type u_1
β : Type ?u.1635266
f g : Perm α
s t : Set α
a b x y : α
⊢ IsCycleOn 1 s ↔ Set.Subsingleton s
Theorem: Finset.sup_induction
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction' s using Finset.cons_induction with c s hc ih
state_before: F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ (b : β), b ∈ s → p (f b)
⊢ p (sup s f)

tactic: exact hb
state_before: case empty
F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs✝ : ∀ (b : β), b ∈ s → p (f b)
hs : ∀ (b : β), b ∈ ∅ → p (f b)
⊢ p (sup ∅ f)

tactic: rw [sup_cons]
state_before: case cons
F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs✝ : ∀ (b : β), b ∈ s✝ → p (f b)
c : β
s : Finset β
hc : ¬c ∈ s
ih : (∀ (b : β), b ∈ s → p (f b)) → p (sup s f)
hs : ∀ (b : β), b ∈ cons c s hc → p (f b)
⊢ p (sup (cons c s hc) f)

tactic: apply hp
state_before: case cons
F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs✝ : ∀ (b : β), b ∈ s✝ → p (f b)
c : β
s : Finset β
hc : ¬c ∈ s
ih : (∀ (b : β), b ∈ s → p (f b)) → p (sup s f)
hs : ∀ (b : β), b ∈ cons c s hc → p (f b)
⊢ p (f c ⊔ sup s f)

tactic: exact hs c (mem_cons.2 (Or.inl rfl))
state_before: case cons.a
F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs✝ : ∀ (b : β), b ∈ s✝ → p (f b)
c : β
s : Finset β
hc : ¬c ∈ s
ih : (∀ (b : β), b ∈ s → p (f b)) → p (sup s f)
hs : ∀ (b : β), b ∈ cons c s hc → p (f b)
⊢ p (f c)

tactic: exact ih fun b h => hs b (mem_cons.2 (Or.inr h))
state_before: case cons.a
F : Type ?u.75184
α : Type u_1
β : Type u_2
γ : Type ?u.75193
ι : Type ?u.75196
κ : Type ?u.75199
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs✝ : ∀ (b : β), b ∈ s✝ → p (f b)
c : β
s : Finset β
hc : ¬c ∈ s
ih : (∀ (b : β), b ∈ s → p (f b)) → p (sup s f)
hs : ∀ (b : β), b ∈ cons c s hc → p (f b)
⊢ p (sup s f)
Theorem: MetricSpace.ext
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: cases m
state_before: α✝ : Type u
β : Type v
X : Type ?u.547543
ι : Type ?u.547546
inst✝ : PseudoMetricSpace α✝
α : Type u_1
m m' : MetricSpace α
h : PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
⊢ m = m'

tactic: cases m'
state_before: case mk
α✝ : Type u
β : Type v
X : Type ?u.547543
ι : Type ?u.547546
inst✝ : PseudoMetricSpace α✝
α : Type u_1
m' : MetricSpace α
toPseudoMetricSpace✝ : PseudoMetricSpace α
eq_of_dist_eq_zero✝ : ∀ {x y : α}, dist x y = 0 → x = y
h : PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
⊢ mk eq_of_dist_eq_zero✝ = m'

tactic: congr
state_before: case mk.mk
α✝ : Type u
β : Type v
X : Type ?u.547543
ι : Type ?u.547546
inst✝ : PseudoMetricSpace α✝
α : Type u_1
toPseudoMetricSpace✝¹ : PseudoMetricSpace α
eq_of_dist_eq_zero✝¹ : ∀ {x y : α}, dist x y = 0 → x = y
toPseudoMetricSpace✝ : PseudoMetricSpace α
eq_of_dist_eq_zero✝ : ∀ {x y : α}, dist x y = 0 → x = y
h : PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
⊢ mk eq_of_dist_eq_zero✝¹ = mk eq_of_dist_eq_zero✝

tactic: ext1
state_before: case mk.mk.e_toPseudoMetricSpace
α✝ : Type u
β : Type v
X : Type ?u.547543
ι : Type ?u.547546
inst✝ : PseudoMetricSpace α✝
α : Type u_1
toPseudoMetricSpace✝¹ : PseudoMetricSpace α
eq_of_dist_eq_zero✝¹ : ∀ {x y : α}, dist x y = 0 → x = y
toPseudoMetricSpace✝ : PseudoMetricSpace α
eq_of_dist_eq_zero✝ : ∀ {x y : α}, dist x y = 0 → x = y
h : PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
⊢ toPseudoMetricSpace✝¹ = toPseudoMetricSpace✝

tactic: assumption
state_before: case mk.mk.e_toPseudoMetricSpace.h
α✝ : Type u
β : Type v
X : Type ?u.547543
ι : Type ?u.547546
inst✝ : PseudoMetricSpace α✝
α : Type u_1
toPseudoMetricSpace✝¹ : PseudoMetricSpace α
eq_of_dist_eq_zero✝¹ : ∀ {x y : α}, dist x y = 0 → x = y
toPseudoMetricSpace✝ : PseudoMetricSpace α
eq_of_dist_eq_zero✝ : ∀ {x y : α}, dist x y = 0 → x = y
h : PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
⊢ PseudoMetricSpace.toDist = PseudoMetricSpace.toDist
Theorem: CategoryTheory.Functor.toEventualRanges_nonempty
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: let ⟨i, f, h⟩ := F.isMittagLeffler_iff_eventualRange.1 h j
state_before: J : Type u
inst✝² : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝¹ : IsCofilteredOrEmpty J
h : IsMittagLeffler F
inst✝ : ∀ (j : J), _root_.Nonempty (F.obj j)
j : J
⊢ _root_.Nonempty ((toEventualRanges F).obj j)

tactic: rw [toEventualRanges_obj, h]
state_before: J : Type u
inst✝² : Category J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝¹ : IsCofilteredOrEmpty J
h✝ : IsMittagLeffler F
inst✝ : ∀ (j : J), _root_.Nonempty (F.obj j)
j i : J
f : i ⟶ j
h : eventualRange F j = range (F.map f)
⊢ _root_.Nonempty ((toEventualRanges F).obj j)

tactic: infer_instance
state_before: J : Type u
inst✝² : Category J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝¹ : IsCofilteredOrEmpty J
h✝ : IsMittagLeffler F
inst✝ : ∀ (j : J), _root_.Nonempty (F.obj j)
j i : J
f : i ⟶ j
h : eventualRange F j = range (F.map f)
⊢ _root_.Nonempty ↑(range (F.map f))
Theorem: intervalIntegral.smul_integral_comp_mul_right
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_right]
state_before: ι : Type ?u.14827562
𝕜 : Type ?u.14827565
E : Type u_1
F : Type ?u.14827571
A : Type ?u.14827574
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ (c • ∫ (x : ℝ) in a..b, f (x * c)) = ∫ (x : ℝ) in a * c..b * c, f x
Theorem: Set.image_neg_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Iio a = Ioi (-a)
Theorem: Set.iUnion_of_singleton_coe
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.166144
γ : Type ?u.166147
ι : Sort ?u.166150
ι' : Sort ?u.166153
ι₂ : Sort ?u.166156
κ : ι → Sort ?u.166161
κ₁ : ι → Sort ?u.166166
κ₂ : ι → Sort ?u.166171
κ' : ι' → Sort ?u.166176
s : Set α
⊢ (⋃ (i : ↑s), {↑i}) = s
Theorem: Set.empty_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.6918
δ : Type ?u.6921
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ ∅ ×ˢ t = ∅

tactic: exact false_and_iff _
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.6918
δ : Type ?u.6921
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x✝ : α × β
⊢ x✝ ∈ ∅ ×ˢ t ↔ x✝ ∈ ∅
Theorem: self_eq_neg
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [← two_nsmul_eq_zero R M, two_smul, add_eq_zero_iff_eq_neg]
state_before: α : Type ?u.296154
R : Type ?u.296157
k : Type ?u.296160
S : Type ?u.296163
M : Type u_1
M₂ : Type ?u.296169
M₃ : Type ?u.296172
ι : Type ?u.296175
inst✝⁴ : Semiring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : CharZero R
v : M
⊢ v = -v ↔ v = 0
Theorem: Commensurable.refl
File: Mathlib/GroupTheory/Commensurable.lean

tactic: simp [Commensurable]
state_before: G : Type u_1
inst✝ : Group G
H : Subgroup G
⊢ Commensurable H H
Theorem: neg_div_self
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [neg_div, div_self h]
state_before: α : Type ?u.38671
β : Type ?u.38674
K : Type u_1
inst✝ : DivisionRing K
a✝ b c d a : K
h : a ≠ 0
⊢ -a / a = -1
Theorem: Zsqrtd.isUnit_iff_norm_isUnit
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [Int.isUnit_iff_natAbs_eq, norm_eq_one_iff]
state_before: d✝ d : ℤ
z : ℤ√d
⊢ IsUnit z ↔ IsUnit (norm z)
Theorem: MeasureTheory.ComplexMeasure.absolutelyContinuous_eNNReal_iff
File: Mathlib/MeasureTheory/Measure/Complex.lean

tactic: constructor <;> intro h
state_before: α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ c ≪ᵥ μ ↔ ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ

tactic: intro i hi
state_before: case mp.right
α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : c ≪ᵥ μ
⊢ ↑im c ≪ᵥ μ

tactic: simp [h hi]
state_before: case mp.right
α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ ↑(↑im c) i = 0

tactic: intro i hi
state_before: case mpr
α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
⊢ c ≪ᵥ μ

tactic: rw [← Complex.re_add_im (c i), (_ : (c i).re = 0), (_ : (c i).im = 0)]
state_before: case mpr
α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ ↑c i = 0

tactic: exacts [by simp, h.2 hi, h.1 hi]
state_before: case mpr
α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ ↑0 + ↑0 * Complex.I = 0

α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ (↑c i).im = 0

α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ (↑c i).re = 0

tactic: simp
state_before: α : Type u_1
β : Type ?u.103329
m : MeasurableSpace α
c : ComplexMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ↑re c ≪ᵥ μ ∧ ↑im c ≪ᵥ μ
i : Set α
hi : ↑μ i = 0
⊢ ↑0 + ↑0 * Complex.I = 0
Theorem: LieIdeal.comap_map_le
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← map_le_iff_le_comap]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
⊢ I ≤ comap f (map f I)
Theorem: sdiff_eq_symm
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← h, sdiff_sdiff_eq_self hy]
state_before: α : Type u
β : Type ?u.30443
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hy : y ≤ x
h : x \ y = z
⊢ x \ z = y
Theorem: PrimeSpectrum.basicOpen_mul
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simp [zeroLocus_singleton_mul]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
⊢ ↑(basicOpen (f * g)) = ↑(basicOpen f ⊓ basicOpen g)
Theorem: RegularSpace.inf
File: Mathlib/Topology/Separation.lean

tactic: rw [inf_eq_iInf]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
X : Type u_1
t₁ t₂ : TopologicalSpace X
h₁ : RegularSpace X
h₂ : RegularSpace X
⊢ RegularSpace X

tactic: exact regularSpace_iInf (Bool.forall_bool.2 ⟨h₂, h₁⟩)
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
X : Type u_1
t₁ t₂ : TopologicalSpace X
h₁ : RegularSpace X
h₂ : RegularSpace X
⊢ RegularSpace X
Theorem: multiplicity.mul
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← PartENat.natCast_get (finite_iff_dom.1 h.1), ←
    PartENat.natCast_get (finite_iff_dom.1 h.2), ←
    PartENat.natCast_get (finite_iff_dom.1 (finite_mul hp h.1 h.2)), ← Nat.cast_add,
    PartENat.natCast_inj, multiplicity.mul' hp]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : Finite p a ∧ Finite p b
⊢ multiplicity p (a * b) = multiplicity p a + multiplicity p b

tactic: rw [eq_top_iff_not_finite.2 (mt (finite_mul_iff hp).1 h)]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : ¬(Finite p a ∧ Finite p b)
⊢ multiplicity p (a * b) = multiplicity p a + multiplicity p b

tactic: cases' not_and_or.1 h with h h <;> simp [eq_top_iff_not_finite.2 h]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
hp : Prime p
h : ¬(Finite p a ∧ Finite p b)
⊢ ⊤ = multiplicity p a + multiplicity p b
Theorem: ContractingWith.dist_le_of_fixedPoint
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: simpa only [hy.eq, dist_self, add_zero] using hf.dist_inequality x y
state_before: α : Type u_1
inst✝ : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
hy : IsFixedPt f y
⊢ dist x y ≤ dist x (f x) / (1 - ↑K)
Theorem: MvPolynomial.map_leftInverse
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [map_map, (RingHom.ext hf : f.comp g = RingHom.id _), map_id]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f✝ f : R →+* S₁
g : S₁ →+* R
hf : LeftInverse ↑f ↑g
X : MvPolynomial σ S₁
⊢ ↑(map f) (↑(map g) X) = X
Theorem: Set.range_list_get?
File: Mathlib/Data/Set/List.lean

tactic: rw [← range_list_nthLe, ← range_comp]
state_before: α : Type u_1
β : Type ?u.1563
l : List α
⊢ range (get? l) = insert none (some '' {x | x ∈ l})

tactic: refine' (range_subset_iff.2 fun n => _).antisymm (insert_subset.2 ⟨_, _⟩)
state_before: α : Type u_1
β : Type ?u.1563
l : List α
⊢ range (get? l) = insert none (range (some ∘ fun k => nthLe l ↑k (_ : ↑k < length l)))

tactic: exacts [(le_or_lt l.length n).imp get?_eq_none.2 (fun hlt => ⟨⟨_, hlt⟩, (get?_eq_get hlt).symm⟩),
  ⟨_, get?_eq_none.2 le_rfl⟩, range_subset_iff.2 <| fun k => ⟨_, get?_eq_get _⟩]
state_before: case refine'_1
α : Type u_1
β : Type ?u.1563
l : List α
n : ℕ
⊢ get? l n ∈ insert none (range (some ∘ fun k => nthLe l ↑k (_ : ↑k < length l)))

case refine'_2
α : Type u_1
β : Type ?u.1563
l : List α
⊢ none ∈ range (get? l)

case refine'_3
α : Type u_1
β : Type ?u.1563
l : List α
⊢ range (some ∘ fun k => nthLe l ↑k (_ : ↑k < length l)) ⊆ range (get? l)
Theorem: TopologicalSpace.exists_dense_seq
File: Mathlib/Topology/Bases.lean

tactic: obtain ⟨s : Set α, hs, s_dense⟩ := exists_countable_dense α
state_before: α : Type u
t : TopologicalSpace α
inst✝¹ : SeparableSpace α
inst✝ : Nonempty α
⊢ ∃ u, DenseRange u

tactic: cases' Set.countable_iff_exists_subset_range.mp hs with u hu
state_before: case intro.intro
α : Type u
t : TopologicalSpace α
inst✝¹ : SeparableSpace α
inst✝ : Nonempty α
s : Set α
hs : Set.Countable s
s_dense : Dense s
⊢ ∃ u, DenseRange u

tactic: exact ⟨u, s_dense.mono hu⟩
state_before: case intro.intro.intro
α : Type u
t : TopologicalSpace α
inst✝¹ : SeparableSpace α
inst✝ : Nonempty α
s : Set α
hs : Set.Countable s
s_dense : Dense s
u : ℕ → α
hu : s ⊆ range u
⊢ ∃ u, DenseRange u