tasksource/leandojo huggingface dataset:
Theorem: omegaLimit_subset_of_tendsto
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: refine' iInter₂_mono' fun u hu ↦ ⟨m ⁻¹' u, tendsto_def.mp hf _ hu, _⟩
state_before: τ : Type u_1
α : Type u_3
β : Type u_2
ι : Type ?u.22929
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
⊢ ω f₁ (fun t x => ϕ (m t) x) s ⊆ ω f₂ ϕ s

tactic: rw [← image2_image_left]
state_before: τ : Type u_1
α : Type u_3
β : Type u_2
ι : Type ?u.22929
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 (fun t x => ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure (image2 ϕ u s)

tactic: exact closure_mono (image2_subset (image_preimage_subset _ _) Subset.rfl)
state_before: τ : Type u_1
α : Type u_3
β : Type u_2
ι : Type ?u.22929
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
m : τ → τ
f₁ f₂ : Filter τ
hf : Tendsto m f₁ f₂
u : Set τ
hu : u ∈ f₂
⊢ closure (image2 ϕ ((fun t => m t) '' (m ⁻¹' u)) s) ⊆ closure (image2 ϕ u s)
Theorem: Polynomial.Monic.natDegree_eq_zero_iff_eq_one
File: Mathlib/Data/Polynomial/Monic.lean

tactic: constructor <;> intro h
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
⊢ natDegree p = 0 ↔ p = 1

tactic: swap
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
⊢ p = 1

case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : p = 1
⊢ natDegree p = 0

tactic: have : p = C (p.coeff 0) := by
  rw [← Polynomial.degree_le_zero_iff]
  rwa [Polynomial.natDegree_eq_zero_iff_degree_le_zero] at h
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
⊢ p = 1

tactic: rw [this]
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
this : p = ↑C (coeff p 0)
⊢ p = 1

tactic: rw [← h, ← Polynomial.leadingCoeff, Monic.def.1 hp, C_1]
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
this : p = ↑C (coeff p 0)
⊢ ↑C (coeff p 0) = 1

tactic: rw [h]
state_before: case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : p = 1
⊢ natDegree p = 0

tactic: exact natDegree_one
state_before: case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : p = 1
⊢ natDegree 1 = 0

tactic: rw [← Polynomial.degree_le_zero_iff]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
⊢ p = ↑C (coeff p 0)

tactic: rwa [Polynomial.natDegree_eq_zero_iff_degree_le_zero] at h
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
h : natDegree p = 0
⊢ degree p ≤ 0
Theorem: CategoryTheory.IsKernelPair.cancel_right_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean

tactic: rw [← cancel_mono f₂, assoc, assoc, big_k.w]
state_before: C : Type u
inst✝¹ : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
f₁ : X ⟶ Y
f₂ : Y ⟶ Z
inst✝ : Mono f₂
big_k : IsKernelPair (f₁ ≫ f₂) a b
⊢ a ≫ f₁ = b ≫ f₁
Theorem: Int.eq_succ_of_zero_lt
File: Std/Data/Int/Lemmas.lean

tactic: rw [Nat.add_comm] at h
state_before: a : Int
h✝ : 0 < a
n : Nat
h : ↑(1 + n) = a
⊢ a = ↑(succ n)

tactic: exact h.symm
state_before: a : Int
h✝ : 0 < a
n : Nat
h : ↑(n + 1) = a
⊢ a = ↑(succ n)
Theorem: finprod_mem_mul_diff'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mul_diff' _ ht, inter_eq_self_of_subset_right hst]
state_before: α : Type u_1
β : Type ?u.362387
ι : Type ?u.362390
G : Type ?u.362393
M : Type u_2
N : Type ?u.362399
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hst : s ⊆ t
ht : Set.Finite (t ∩ mulSupport f)
⊢ ((∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t \ s), f i) = ∏ᶠ (i : α) (_ : i ∈ t), f i
Theorem: Filter.iInf_sets_eq_finite
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [iInf_eq_iInf_finset, iInf_sets_eq]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.101230
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type u_1
f : ι → Filter α
⊢ (⨅ (i : ι), f i).sets = ⋃ (t : Finset ι), (⨅ (i : ι) (_ : i ∈ t), f i).sets

tactic: exact directed_of_sup fun _ _ => biInf_mono
state_before: case h
α : Type u
β : Type v
γ : Type w
δ : Type ?u.101230
ι✝ : Sort x
f✝ g : Filter α
s t : Set α
ι : Type u_1
f : ι → Filter α
⊢ Directed (fun x x_1 => x ≥ x_1) fun t => ⨅ (i : ι) (_ : i ∈ t), f i
Theorem: Finset.sup_erase_bot
File: Mathlib/Data/Finset/Lattice.lean

tactic: refine' (sup_mono (s.erase_subset _)).antisymm (Finset.sup_le_iff.2 fun a ha => _)
state_before: F : Type ?u.58882
α : Type u_1
β : Type ?u.58888
γ : Type ?u.58891
ι : Type ?u.58894
κ : Type ?u.58897
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
s : Finset α
⊢ sup (erase s ⊥) id = sup s id

tactic: obtain rfl | ha' := eq_or_ne a ⊥
state_before: F : Type ?u.58882
α : Type u_1
β : Type ?u.58888
γ : Type ?u.58891
ι : Type ?u.58894
κ : Type ?u.58897
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a✝ : α
inst✝ : DecidableEq α
s : Finset α
a : α
ha : a ∈ s
⊢ id a ≤ sup (erase s ⊥) id

tactic: exact bot_le
state_before: case inl
F : Type ?u.58882
α : Type u_1
β : Type ?u.58888
γ : Type ?u.58891
ι : Type ?u.58894
κ : Type ?u.58897
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
s : Finset α
ha : ⊥ ∈ s
⊢ id ⊥ ≤ sup (erase s ⊥) id

tactic: exact le_sup (mem_erase.2 ⟨ha', ha⟩)
state_before: case inr
F : Type ?u.58882
α : Type u_1
β : Type ?u.58888
γ : Type ?u.58891
ι : Type ?u.58894
κ : Type ?u.58897
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s✝ s₁ s₂ : Finset β
f g : β → α
a✝ : α
inst✝ : DecidableEq α
s : Finset α
a : α
ha : a ∈ s
ha' : a ≠ ⊥
⊢ id a ≤ sup (erase s ⊥) id
Theorem: List.sublistsAux_eq_bind
File: Mathlib/Data/List/Sublists.lean

tactic: simp [sublistsAux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a [] = List.bind [] fun l => [l, a :: l]

tactic: rw [bind_append, ← ih, bind_singleton, sublistsAux, foldl_append]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r✝ r : List (List α)
l : List α
ih : sublistsAux a r = List.bind r fun l => [l, a :: l]
⊢ sublistsAux a (r ++ [l]) = List.bind (r ++ [l]) fun l => [l, a :: l]

tactic: simp [sublistsAux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r✝ r : List (List α)
l : List α
ih : sublistsAux a r = List.bind r fun l => [l, a :: l]
⊢ foldl (fun r l => r ++ [l, a :: l]) (foldl (fun r l => r ++ [l, a :: l]) [] r) [l] = sublistsAux a r ++ [l, a :: l]
Theorem: Finset.uIcc_subset_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [mem_Icc] at ha hb
state_before: ι : Type ?u.185526
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₁ ∈ Icc a₂ b₂
hb : b₁ ∈ Icc a₂ b₂
⊢ [[a₁, b₁]] ⊆ Icc a₂ b₂

tactic: exact Icc_subset_Icc (_root_.le_inf ha.1 hb.1) (_root_.sup_le ha.2 hb.2)
state_before: ι : Type ?u.185526
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁ ∧ a₁ ≤ b₂
hb : a₂ ≤ b₁ ∧ b₁ ≤ b₂
⊢ [[a₁, b₁]] ⊆ Icc a₂ b₂
Theorem: Rat.maybeNormalize_eq
File: Std/Data/Rat/Lemmas.lean

tactic: unfold maybeNormalize
state_before: num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : Nat.coprime (Int.natAbs (Int.div num ↑g)) (den / g)
⊢ maybeNormalize num den g den_nz reduced = mk' (Int.div num ↑g) (den / g)

tactic: split
state_before: num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : Nat.coprime (Int.natAbs (Int.div num ↑g)) (den / g)
⊢ (if hg : g = 1 then mk' num den else mk' (Int.div num ↑g) (den / g)) = mk' (Int.div num ↑g) (den / g)

tactic: subst g
state_before: case inl
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : Nat.coprime (Int.natAbs (Int.div num ↑g)) (den / g)
h✝ : g = 1
⊢ mk' num den = mk' (Int.div num ↑g) (den / g)

tactic: simp
state_before: case inl
num : Int
den : Nat
den_nz : den / 1 ≠ 0
reduced : Nat.coprime (Int.natAbs (Int.div num ↑1)) (den / 1)
⊢ mk' num den = mk' (Int.div num ↑1) (den / 1)

tactic: rfl
state_before: case inr
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : Nat.coprime (Int.natAbs (Int.div num ↑g)) (den / g)
h✝ : ¬g = 1
⊢ mk' (Int.div num ↑g) (den / g) = mk' (Int.div num ↑g) (den / g)
Theorem: Polynomial.roots_X_pow
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [roots_pow, roots_X]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
n : ℕ
⊢ roots (X ^ n) = n • {0}
Theorem: PrimrecPred.not
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.132671
γ : Type ?u.132674
δ : Type ?u.132677
σ : Type ?u.132680
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
n : α
⊢ (!decide (p n)) = decide ((fun a => ¬p a) n)
Theorem: TopCat.piIsoPi_hom_apply
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: have := piIsoPi_inv_π α i
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
x : ↑(∏ α)
⊢ (forget TopCat).map (piIsoPi α).hom x i = (forget TopCat).map (Pi.π α i) x

tactic: rw [Iso.inv_comp_eq] at this
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
x : ↑(∏ α)
this : (piIsoPi α).inv ≫ Pi.π α i = piπ α i
⊢ (forget TopCat).map (piIsoPi α).hom x i = (forget TopCat).map (Pi.π α i) x

tactic: exact ConcreteCategory.congr_hom this x
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
x : ↑(∏ α)
this : Pi.π α i = (piIsoPi α).hom ≫ piπ α i
⊢ (forget TopCat).map (piIsoPi α).hom x i = (forget TopCat).map (Pi.π α i) x
Theorem: QuotientMap.comp
File: Mathlib/Topology/Maps.lean

tactic: rw [hg.right, hf.right, coinduced_compose]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.137449
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
f : α → β
hg : QuotientMap g
hf : QuotientMap f
⊢ inst✝¹ = coinduced (g ∘ f) inst✝³
Theorem: NeZero.of_injective
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [← ZeroHomClass.map_zero f]
state_before: α : Type ?u.1488
β : Type ?u.1491
M✝ : Type ?u.1494
N : Type ?u.1497
P : Type ?u.1500
G : Type ?u.1503
H : Type ?u.1506
F : Type u_3
R : Type u_1
M : Type u_2
inst✝³ : Zero R
r : R
inst✝² : NeZero r
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
hf : Function.Injective ↑f
⊢ ↑f r ≠ 0

tactic: exact hf.ne NeZero.out
state_before: α : Type ?u.1488
β : Type ?u.1491
M✝ : Type ?u.1494
N : Type ?u.1497
P : Type ?u.1500
G : Type ?u.1503
H : Type ?u.1506
F : Type u_3
R : Type u_1
M : Type u_2
inst✝³ : Zero R
r : R
inst✝² : NeZero r
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
hf : Function.Injective ↑f
⊢ ↑f r ≠ ↑f 0
Theorem: Polynomial.mirror_trailingCoeff
File: Mathlib/Data/Polynomial/Mirror.lean

tactic: rw [leadingCoeff, trailingCoeff, mirror_natTrailingDegree, coeff_mirror,
  revAt_le (Nat.le_add_left _ _), add_tsub_cancel_right]
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ trailingCoeff (mirror p) = leadingCoeff p
Theorem: CategoryTheory.induct_on_objects
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: let aux (j₁ j₂ : J) (f : j₁ ⟶  j₂) := congrArg ULift.up <| (h1 f).to_eq
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
p : Set J
j₀ : J
h0 : j₀ ∈ p
h1 : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)
j : J
⊢ j ∈ p

tactic: injection constant_of_preserves_morphisms (fun k => ULift.up (k ∈ p)) aux j j₀ with i
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
p : Set J
j₀ : J
h0 : j₀ ∈ p
h1 : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)
j : J
aux : ∀ (j₁ j₂ : J), (j₁ ⟶ j₂) → { down := j₁ ∈ p } = { down := j₂ ∈ p } :=
  fun j₁ j₂ f => congrArg ULift.up (Iff.to_eq (h1 f))
⊢ j ∈ p

tactic: rwa [i]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
p : Set J
j₀ : J
h0 : j₀ ∈ p
h1 : ∀ {j₁ j₂ : J}, (j₁ ⟶ j₂) → (j₁ ∈ p ↔ j₂ ∈ p)
j : J
aux : ∀ (j₁ j₂ : J), (j₁ ⟶ j₂) → { down := j₁ ∈ p } = { down := j₂ ∈ p } :=
  fun j₁ j₂ f => congrArg ULift.up (Iff.to_eq (h1 f))
i : (j ∈ p) = (j₀ ∈ p)
⊢ j ∈ p
Theorem: MvPolynomial.rename_expand
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: simp [expand, bind₁_rename, rename_bind₁, Function.comp]
state_before: σ : Type u_1
τ : Type u_3
R : Type u_2
S : Type ?u.281360
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
p : ℕ
φ : MvPolynomial σ R
⊢ ↑(rename f) (↑(expand p) φ) = ↑(expand p) (↑(rename f) φ)
Theorem: Complex.sinh_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, ← mul_assoc, two_sin, mul_assoc, I_mul_I,
  mul_neg_one, neg_sub, neg_mul_eq_neg_mul]
state_before: x y : ℂ
⊢ sinh (x * I) = sin x * I
Theorem: CategoryTheory.GrothendieckTopology.toPlus_comp_plusCompIso_inv
File: Mathlib/CategoryTheory/Sites/CompatiblePlus.lean

tactic: simp [Iso.comp_inv_eq]
state_before: C : Type u
inst✝⁸ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category D
E : Type w₂
inst✝⁶ : Category E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
⊢ toPlus J (P ⋙ F) ≫ (plusCompIso J F P).inv = whiskerRight (toPlus J P) F
Theorem: Balanced.sub
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: simp_rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.43430
E : Type u_2
ι : Sort ?u.43436
κ : ι → Sort ?u.43441
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
hs : Balanced 𝕜 s
ht : Balanced 𝕜 t
⊢ Balanced 𝕜 (s - t)

tactic: exact hs.add ht.neg
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.43430
E : Type u_2
ι : Sort ?u.43436
κ : ι → Sort ?u.43441
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
hs : Balanced 𝕜 s
ht : Balanced 𝕜 t
⊢ Balanced 𝕜 (s + -t)
Theorem: PseudoEpimorphism.cancel_left
File: Mathlib/Topology/Order/Hom/Esakia.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.72756
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.72768
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
g : PseudoEpimorphism β γ
f₁ f₂ : PseudoEpimorphism α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Cardinal.lift_iSup_le_lift_iSup
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [lift_iSup hf, lift_iSup hf']
state_before: α β : Type u
ι : Type v
ι' : Type v'
f : ι → Cardinal
f' : ι' → Cardinal
hf : BddAbove (range f)
hf' : BddAbove (range f')
g : ι → ι'
h : ∀ (i : ι), lift (f i) ≤ lift (f' (g i))
⊢ lift (iSup f) ≤ lift (iSup f')

tactic: exact ciSup_mono' (bddAbove_range_comp.{_,_,w} hf' _) fun i => ⟨_, h i⟩
state_before: α β : Type u
ι : Type v
ι' : Type v'
f : ι → Cardinal
f' : ι' → Cardinal
hf : BddAbove (range f)
hf' : BddAbove (range f')
g : ι → ι'
h : ∀ (i : ι), lift (f i) ≤ lift (f' (g i))
⊢ (⨆ (i : ι), lift (f i)) ≤ ⨆ (i : ι'), lift (f' i)
Theorem: MeasureTheory.lintegral_eq_top_of_measure_eq_top_pos
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [mul_eq_top, hμf.ne.symm]
state_before: α : Type u_1
β : Type ?u.963625
γ : Type ?u.963628
δ : Type ?u.963631
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
hμf : 0 < ↑↑μ {x | f x = ⊤}
⊢ ⊤ = ⊤ * ↑↑μ {x | ⊤ ≤ f x}
Theorem: List.mem_product
File: Mathlib/Data/List/ProdSigma.lean

tactic: simp_all [SProd.sprod, product, mem_bind, mem_map, Prod.ext_iff, exists_prop, and_left_comm,
  exists_and_left, exists_eq_left, exists_eq_right]
state_before: α : Type u_1
β : Type u_2
l₁ : List α
l₂ : List β
a : α
b : β
⊢ (a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂
Theorem: PadicInt.padic_norm_e_of_padicInt
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: simp [norm_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z : ℤ_[p]
⊢ ‖↑z‖ = ‖z‖
Theorem: Multiset.disjoint_finset_sum_right
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa only [disjoint_comm] using disjoint_finset_sum_left
state_before: ι : Type ?u.902298
β✝ : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β✝
β : Type u_1
i : Finset β
f : β → Multiset α
a : Multiset α
⊢ Disjoint a (Finset.sum i f) ↔ ∀ (b : β), b ∈ i → Disjoint a (f b)
Theorem: Set.strictMonoOn_projIcc
File: Mathlib/Data/Set/Intervals/ProjIcc.lean

tactic: simpa only [projIcc_of_mem, hx, hy]
state_before: α : Type u_1
β : Type ?u.10840
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ x : α
hx : x ∈ Icc a b
y : α
hy : y ∈ Icc a b
hxy : x < y
⊢ projIcc a b h x < projIcc a b h y
Theorem: Set.offDiag_inter
File: Mathlib/Data/Set/Prod.lean

tactic: simp only [mem_offDiag, mem_inter_iff]
state_before: α : Type u_1
s t : Set α
x✝ : α × α
a : α
x : α × α
⊢ x ∈ offDiag (s ∩ t) ↔ x ∈ offDiag s ∩ offDiag t

tactic: tauto
state_before: α : Type u_1
s t : Set α
x✝ : α × α
a : α
x : α × α
⊢ (x.fst ∈ s ∧ x.fst ∈ t) ∧ (x.snd ∈ s ∧ x.snd ∈ t) ∧ x.fst ≠ x.snd ↔
    (x.fst ∈ s ∧ x.snd ∈ s ∧ x.fst ≠ x.snd) ∧ x.fst ∈ t ∧ x.snd ∈ t ∧ x.fst ≠ x.snd
Theorem: AddMonoidAlgebra.lift_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [lift_def, liftNC_single, Algebra.smul_def, AddMonoidHom.coe_coe]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2710730
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.2710767
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : Multiplicative G →* A
a : G
b : k
⊢ ↑(↑(lift k G A) F) (single a b) = b • ↑F (↑Multiplicative.ofAdd a)
Theorem: exists_countable_dense_no_bot_top
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa using dense_univ.exists_countable_dense_subset_no_bot_top
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
inst✝¹ : SeparableSpace α
inst✝ : Nontrivial α
⊢ ∃ s, Set.Countable s ∧ Dense s ∧ (∀ (x : α), IsBot x → ¬x ∈ s) ∧ ∀ (x : α), IsTop x → ¬x ∈ s
Theorem: IsCoprime.mul_add_left_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (y * z + x) y

tactic: exact h.add_mul_left_left z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z) y
Theorem: Equiv.Perm.mem_support
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [support, mem_filter, and_iff_right (mem_univ x)]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ x ∈ support f ↔ ↑f x ≠ x
Theorem: Filter.comap_sup
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [sup_eq_iSup, comap_iSup, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.256139
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂
Theorem: FirstOrder.Language.realize_denselyOrdered_iff
File: Mathlib/ModelTheory/Order.lean

tactic: simp only [denselyOrderedSentence, Sentence.Realize, Formula.Realize,
  BoundedFormula.realize_imp, BoundedFormula.realize_all, Term.realize, Term.realize_lt,
  Sum.elim_inr, BoundedFormula.realize_ex, BoundedFormula.realize_inf]
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : Preorder M
⊢ M ⊨ denselyOrderedSentence Language.order ↔ DenselyOrdered M

tactic: refine' ⟨fun h => ⟨fun a b ab => h a b ab⟩, _⟩
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : Preorder M
⊢ (∀ (a a_1 : M),
      Fin.snoc (Fin.snoc default a) a_1 0 < Fin.snoc (Fin.snoc default a) a_1 1 →
        ∃ a_3,
          Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 0 < Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 2 ∧
            Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 2 < Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 1) ↔
    DenselyOrdered M

tactic: intro h a b ab
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : Preorder M
⊢ DenselyOrdered M →
    ∀ (a a_1 : M),
      Fin.snoc (Fin.snoc default a) a_1 0 < Fin.snoc (Fin.snoc default a) a_1 1 →
        ∃ a_3,
          Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 0 < Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 2 ∧
            Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 2 < Fin.snoc (Fin.snoc (Fin.snoc default a) a_1) a_3 1

tactic: exact exists_between ab
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : Preorder M
h : DenselyOrdered M
a b : M
ab : Fin.snoc (Fin.snoc default a) b 0 < Fin.snoc (Fin.snoc default a) b 1
⊢ ∃ a_1,
    Fin.snoc (Fin.snoc (Fin.snoc default a) b) a_1 0 < Fin.snoc (Fin.snoc (Fin.snoc default a) b) a_1 2 ∧
      Fin.snoc (Fin.snoc (Fin.snoc default a) b) a_1 2 < Fin.snoc (Fin.snoc (Fin.snoc default a) b) a_1 1
Theorem: tsum_eq_zero_add'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa only [sum_range_one] using (sum_add_tsum_nat_add' hf).symm
state_before: α : Type ?u.460879
β : Type ?u.460882
γ : Type ?u.460885
δ : Type ?u.460888
inst✝⁶ : AddCommGroup α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalAddGroup α
f✝ g : β → α
a a₁ a₂ : α
M : Type u_1
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : ContinuousAdd M
inst✝ : T2Space M
f : ℕ → M
hf : Summable fun n => f (n + 1)
⊢ (∑' (b : ℕ), f b) = f 0 + ∑' (b : ℕ), f (b + 1)
Theorem: derivWithin_congr
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ derivWithin f₁ s x = derivWithin f s x

tactic: rw [fderivWithin_congr hs hx]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ ↑(fderivWithin 𝕜 f₁ s x) 1 = ↑(fderivWithin 𝕜 f s x) 1