tasksource/leandojo huggingface dataset:
Theorem: exists_open_nhds_one_split
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: have : (fun a : M × M => a.1 * a.2) ⁻¹' s ∈ 𝓝 ((1, 1) : M × M) :=
  tendsto_mul (by simpa only [one_mul] using hs)
state_before: ι : Type ?u.155162
α : Type ?u.155165
X : Type ?u.155168
M : Type u_1
N : Type ?u.155174
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ s

tactic: simpa only [prod_subset_iff] using exists_nhds_square this
state_before: ι : Type ?u.155162
α : Type ?u.155165
X : Type ?u.155168
M : Type u_1
N : Type ?u.155174
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
this : (fun a => a.fst * a.snd) ⁻¹' s ∈ 𝓝 (1, 1)
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ s

tactic: simpa only [one_mul] using hs
state_before: ι : Type ?u.155162
α : Type ?u.155165
X : Type ?u.155168
M : Type u_1
N : Type ?u.155174
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
⊢ s ∈ 𝓝 (1 * 1)
Theorem: CategoryTheory.Limits.cokernel_funext
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: apply coequalizer.hom_ext
state_before: C : Type u_1
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w :
  ∀ (n : (forget C).obj N),
    (forget C).map g ((forget C).map (cokernel.π f) n) = (forget C).map h ((forget C).map (cokernel.π f) n)
⊢ g = h

tactic: apply ConcreteCategory.hom_ext _ _
state_before: case h
C : Type u_1
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w :
  ∀ (n : (forget C).obj N),
    (forget C).map g ((forget C).map (cokernel.π f) n) = (forget C).map h ((forget C).map (cokernel.π f) n)
⊢ coequalizer.π f 0 ≫ g = coequalizer.π f 0 ≫ h

tactic: simpa using w
state_before: case h
C : Type u_1
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w :
  ∀ (n : (forget C).obj N),
    (forget C).map g ((forget C).map (cokernel.π f) n) = (forget C).map h ((forget C).map (cokernel.π f) n)
⊢ ∀ (x : (forget C).obj N), (forget C).map (coequalizer.π f 0 ≫ g) x = (forget C).map (coequalizer.π f 0 ≫ h) x
Theorem: symmDiff_top'
File: Mathlib/Order/SymmDiff.lean

tactic: simp [symmDiff]
state_before: ι : Type ?u.53407
α : Type u_1
β : Type ?u.53413
π : ι → Type ?u.53418
inst✝ : CoheytingAlgebra α
a : α
⊢ a ∆ ⊤ = ￢a
Theorem: Finset.disjoint_image
File: Mathlib/Data/Finset/Image.lean

tactic: rw [←disjoint_map ⟨_, hf⟩]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112000
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
s t : Finset α
f : α → β
hf : Injective f
⊢ _root_.Disjoint (image f s) (image f t) ↔ _root_.Disjoint s t

tactic: simp [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.112000
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
s t : Finset α
f : α → β
hf : Injective f
⊢ _root_.Disjoint (image f s) (image f t) ↔
    _root_.Disjoint (map { toFun := f, inj' := hf } s) (map { toFun := f, inj' := hf } t)
Theorem: Nat.Prime.dvd_of_dvd_pow
File: Mathlib/Data/Nat/Prime.lean

tactic: induction' n with n IH
state_before: p m n : ℕ
pp : Prime p
h : p ∣ m ^ n
⊢ p ∣ m

tactic: exact pp.not_dvd_one.elim h
state_before: case zero
p m n : ℕ
pp : Prime p
h✝ : p ∣ m ^ n
h : p ∣ m ^ zero
⊢ p ∣ m

tactic: rw [pow_succ] at h
state_before: case succ
p m n✝ : ℕ
pp : Prime p
h✝ : p ∣ m ^ n✝
n : ℕ
IH : p ∣ m ^ n → p ∣ m
h : p ∣ m ^ succ n
⊢ p ∣ m

tactic: exact (pp.dvd_mul.1 h).elim IH id
state_before: case succ
p m n✝ : ℕ
pp : Prime p
h✝ : p ∣ m ^ n✝
n : ℕ
IH : p ∣ m ^ n → p ∣ m
h : p ∣ m ^ n * m
⊢ p ∣ m
Theorem: PadicSeq.norm_eq_norm_app_of_nonzero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp [norm, hf]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
⊢ norm f = padicNorm p (↑f (stationaryPoint hf))

tactic: simpa [h] using heq
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
heq : norm f = padicNorm p (↑f (stationaryPoint hf))
h : ↑f (stationaryPoint hf) = 0
⊢ norm f = 0
Theorem: Metric.exists_dist_lt_of_hausdorffDist_lt
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: have r0 : 0 < r := lt_of_le_of_lt hausdorffDist_nonneg H
state_before: ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
⊢ ∃ y, y ∈ t ∧ dist x y < r

tactic: have : hausdorffEdist s t < ENNReal.ofReal r := by
  rwa [hausdorffDist, ← ENNReal.toReal_ofReal (le_of_lt r0),
    ENNReal.toReal_lt_toReal fin ENNReal.ofReal_ne_top] at H
state_before: ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
r0 : 0 < r
⊢ ∃ y, y ∈ t ∧ dist x y < r

tactic: rcases exists_edist_lt_of_hausdorffEdist_lt h this with ⟨y, hy, yr⟩
state_before: ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
r0 : 0 < r
this : hausdorffEdist s t < ENNReal.ofReal r
⊢ ∃ y, y ∈ t ∧ dist x y < r

tactic: rw [edist_dist, ENNReal.ofReal_lt_ofReal_iff r0] at yr
state_before: case intro.intro
ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y✝ : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
r0 : 0 < r
this : hausdorffEdist s t < ENNReal.ofReal r
y : α
hy : y ∈ t
yr : edist x y < ENNReal.ofReal r
⊢ ∃ y, y ∈ t ∧ dist x y < r

tactic: exact ⟨y, hy, yr⟩
state_before: case intro.intro
ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y✝ : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
r0 : 0 < r
this : hausdorffEdist s t < ENNReal.ofReal r
y : α
hy : y ∈ t
yr : dist x y < r
⊢ ∃ y, y ∈ t ∧ dist x y < r

tactic: rwa [hausdorffDist, ← ENNReal.toReal_ofReal (le_of_lt r0),
  ENNReal.toReal_lt_toReal fin ENNReal.ofReal_ne_top] at H
state_before: ι : Sort ?u.78581
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
r : ℝ
h : x ∈ s
H : hausdorffDist s t < r
fin : hausdorffEdist s t ≠ ⊤
r0 : 0 < r
⊢ hausdorffEdist s t < ENNReal.ofReal r
Theorem: List.toFinset_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.476415
γ : Type ?u.476418
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
⊢ toFinset (l ∩ l') = toFinset l ∩ toFinset l'

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.476415
γ : Type ?u.476418
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ toFinset (l ∩ l') ↔ a✝ ∈ toFinset l ∩ toFinset l'
Theorem: Metric.le_glueDist_inr_inl
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: rw [glueDist_comm]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : Y
y : X
⊢ ε ≤ glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y)

tactic: apply le_glueDist_inl_inr
state_before: X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
Φ : Z → X
Ψ : Z → Y
ε : ℝ
x : Y
y : X
⊢ ε ≤ glueDist Φ Ψ ε (Sum.inl y) (Sum.inr x)
Theorem: FirstOrder.Language.Substructure.coe_iInf
File: Mathlib/ModelTheory/Substructures.lean

tactic: simp only [iInf, coe_sInf, Set.biInter_range]
state_before: L : Language
M : Type w
N : Type ?u.19468
P : Type ?u.19471
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S✝ : Substructure L M
ι : Sort u_1
S : ι → Substructure L M
⊢ ↑(⨅ (i : ι), S i) = ⋂ (i : ι), ↑(S i)
Theorem: List.Ico.filter_le_of_bot
File: Mathlib/Data/List/Intervals.lean

tactic: rw [← filter_lt_of_succ_bot hnm]
state_before: n m : ℕ
hnm : n < m
⊢ filter (fun x => decide (x ≤ n)) (Ico n m) = [n]

tactic: exact filter_congr' fun _ _ => by
  rw [decide_eq_true_eq, decide_eq_true_eq]
  exact lt_succ_iff.symm
state_before: n m : ℕ
hnm : n < m
⊢ filter (fun x => decide (x ≤ n)) (Ico n m) = filter (fun x => decide (x < n + 1)) (Ico n m)

tactic: rw [decide_eq_true_eq, decide_eq_true_eq]
state_before: n m : ℕ
hnm : n < m
x✝¹ : ℕ
x✝ : x✝¹ ∈ Ico n m
⊢ decide (x✝¹ ≤ n) = true ↔ decide (x✝¹ < n + 1) = true

tactic: exact lt_succ_iff.symm
state_before: n m : ℕ
hnm : n < m
x✝¹ : ℕ
x✝ : x✝¹ ∈ Ico n m
⊢ x✝¹ ≤ n ↔ x✝¹ < n + 1
Theorem: CategoryTheory.Presieve.is_compatible_of_exists_amalgamation
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: cases' h with t ht
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
h : ∃ t, FamilyOfElements.IsAmalgamation x t
⊢ FamilyOfElements.Compatible x

tactic: intro Y₁ Y₂ Z g₁ g₂ f₁ f₂ h₁ h₂ comm
state_before: case intro
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
t : P.obj X.op
ht : FamilyOfElements.IsAmalgamation x t
⊢ FamilyOfElements.Compatible x

tactic: rw [← ht _ h₁, ← ht _ h₂, ← FunctorToTypes.map_comp_apply, ← op_comp, comm]
state_before: case intro
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
t : P.obj X.op
ht : FamilyOfElements.IsAmalgamation x t
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : R f₁
h₂ : R f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ P.map g₁.op (x f₁ h₁) = P.map g₂.op (x f₂ h₂)

tactic: simp
state_before: case intro
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
t : P.obj X.op
ht : FamilyOfElements.IsAmalgamation x t
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : R f₁
h₂ : R f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ P.map (g₂ ≫ f₂).op t = P.map g₂.op (P.map f₂.op t)
Theorem: Part.eq_of_chain
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: cases' ha with i ha
state_before: α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
ha : some a ∈ c
hb : some b ∈ c
⊢ a = b

tactic: replace ha := ha.symm
state_before: case intro
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
hb : some b ∈ c
i : ℕ
ha : some a = ↑c i
⊢ a = b

tactic: cases' hb with j hb
state_before: case intro
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
hb : some b ∈ c
i : ℕ
ha : ↑c i = some a
⊢ a = b

tactic: replace hb := hb.symm
state_before: case intro.intro
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : ↑c i = some a
j : ℕ
hb : some b = ↑c j
⊢ a = b

tactic: rw [eq_some_iff] at ha hb
state_before: case intro.intro
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : ↑c i = some a
j : ℕ
hb : ↑c j = some b
⊢ a = b

tactic: cases' le_total i j with hij hji
state_before: case intro.intro
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
⊢ a = b

tactic: . have := c.monotone hij _ ha; apply mem_unique this hb
state_before: case intro.intro.inl
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hij : i ≤ j
⊢ a = b

case intro.intro.inr
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hji : j ≤ i
⊢ a = b

tactic: . have := c.monotone hji _ hb; apply Eq.symm; apply mem_unique this ha
state_before: case intro.intro.inr
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hji : j ≤ i
⊢ a = b

tactic: have := c.monotone hij _ ha
state_before: case intro.intro.inl
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hij : i ≤ j
⊢ a = b

tactic: apply mem_unique this hb
state_before: case intro.intro.inl
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hij : i ≤ j
this : a ∈ ↑c j
⊢ a = b

tactic: have := c.monotone hji _ hb
state_before: case intro.intro.inr
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hji : j ≤ i
⊢ a = b

tactic: apply Eq.symm
state_before: case intro.intro.inr
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hji : j ≤ i
this : b ∈ ↑c i
⊢ a = b

tactic: apply mem_unique this ha
state_before: case intro.intro.inr.h
α : Type u
β : Type v
γ : Type ?u.13795
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ ↑c i
j : ℕ
hb : b ∈ ↑c j
hji : j ≤ i
this : b ∈ ↑c i
⊢ b = a
Theorem: subset_piiUnionInter
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: have h_ss : {i} ⊆ S := by
  intro j hj
  rw [mem_singleton_iff] at hj
  rwa [hj]
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
⊢ π i ⊆ piiUnionInter π S

tactic: refine' Subset.trans _ (piiUnionInter_mono_right h_ss)
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π S

tactic: rw [piiUnionInter_singleton]
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π {i}

tactic: exact subset_union_left _ _
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ π i ∪ {univ}

tactic: intro j hj
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
⊢ {i} ⊆ S

tactic: rw [mem_singleton_iff] at hj
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
j : ι
hj : j ∈ {i}
⊢ j ∈ S

tactic: rwa [hj]
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
j : ι
hj : j = i
⊢ j ∈ S
Theorem: derivWithin_div_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simp [div_eq_inv_mul, derivWithin_const_mul, hc, hxs]
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 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d✝ : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : DifferentiableWithinAt 𝕜 c s x
d : 𝕜'
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ derivWithin (fun x => c x / d) s x = derivWithin c s x / d
Theorem: CategoryTheory.NatTrans.hcomp_id_app
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G H✝ I : C ⥤ D
H : D ⥤ E
α : F ⟶ G
X : C
⊢ (α ◫ 𝟙 H).app X = H.map (α.app X)
Theorem: Nat.eq_one_of_dvd_one
File: Std/Data/Nat/Lemmas.lean

tactic: decide
state_before: n : Nat
H : n ∣ 1
⊢ 0 < 1

tactic: decide
state_before: n : Nat
H : n ∣ 1
⊢ 0 < 1
Theorem: Monotone.partialSups_eq
File: Mathlib/Order/PartialSups.lean

tactic: ext n
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
hf : Monotone f
⊢ ↑(partialSups f) = f

tactic: induction' n with n ih
state_before: case h
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
hf : Monotone f
n : ℕ
⊢ ↑(partialSups f) n = f n

tactic: rfl
state_before: case h.zero
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
hf : Monotone f
⊢ ↑(partialSups f) Nat.zero = f Nat.zero

tactic: rw [partialSups_succ, ih, sup_eq_right.2 (hf (Nat.le_succ _))]
state_before: case h.succ
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
hf : Monotone f
n : ℕ
ih : ↑(partialSups f) n = f n
⊢ ↑(partialSups f) (Nat.succ n) = f (Nat.succ n)
Theorem: Set.image2_inter_subset_left
File: Mathlib/Data/Set/NAry.lean

tactic: rintro _ ⟨a, b, ⟨h1a, h2a⟩, hb, rfl⟩
state_before: α : Type u_2
α' : Type ?u.21899
β : Type u_3
β' : Type ?u.21905
γ : Type u_1
γ' : Type ?u.21911
δ : Type ?u.21914
δ' : Type ?u.21917
ε : Type ?u.21920
ε' : Type ?u.21923
ζ : Type ?u.21926
ζ' : Type ?u.21929
ν : Type ?u.21932
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') t ⊆ image2 f s t ∩ image2 f s' t

tactic: constructor <;> exact ⟨_, _, ‹_›, ‹_›, rfl⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_2
α' : Type ?u.21899
β : Type u_3
β' : Type ?u.21905
γ : Type u_1
γ' : Type ?u.21911
δ : Type ?u.21914
δ' : Type ?u.21917
ε : Type ?u.21920
ε' : Type ?u.21923
ζ : Type ?u.21926
ζ' : Type ?u.21929
ν : Type ?u.21932
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
a : α
b : β
h1a : a ∈ s
h2a : a ∈ s'
hb : b ∈ t
⊢ f a b ∈ image2 f s t ∩ image2 f s' t
Theorem: Int.div_mul_cancel_of_mod_eq_zero
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, mul_div_cancel_of_mod_eq_zero H]
state_before: a b : Int
H : mod a b = 0
⊢ div a b * b = a
Theorem: exists_lub_Iio
File: Mathlib/Order/Bounds/Basic.lean

tactic: by_cases h_exists_lt : ∃ j, j ∈ upperBounds (Iio i) ∧ j < i
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
⊢ ∃ j, IsLUB (Iio i) j

tactic: obtain ⟨j, hj_ub, hj_lt_i⟩ := h_exists_lt
state_before: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ∃ j, j ∈ upperBounds (Iio i) ∧ j < i
⊢ ∃ j, IsLUB (Iio i) j

tactic: exact ⟨j, hj_ub, fun k hk_ub => hk_ub hj_lt_i⟩
state_before: case pos.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i j : γ
hj_ub : j ∈ upperBounds (Iio i)
hj_lt_i : j < i
⊢ ∃ j, IsLUB (Iio i) j

tactic: refine' ⟨i, fun j hj => le_of_lt hj, _⟩
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
⊢ ∃ j, IsLUB (Iio i) j

tactic: rw [mem_lowerBounds]
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
⊢ i ∈ lowerBounds (upperBounds (Iio i))

tactic: by_contra h
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
⊢ ∀ (x : γ), x ∈ upperBounds (Iio i) → i ≤ x

tactic: refine' h_exists_lt _
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
h : ¬∀ (x : γ), x ∈ upperBounds (Iio i) → i ≤ x
⊢ False

tactic: push_neg at h
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
h : ¬∀ (x : γ), x ∈ upperBounds (Iio i) → i ≤ x
⊢ ∃ j, j ∈ upperBounds (Iio i) ∧ j < i

tactic: exact h
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : LinearOrder γ
i : γ
h_exists_lt : ¬∃ j, j ∈ upperBounds (Iio i) ∧ j < i
h : ∃ x, x ∈ upperBounds (Iio i) ∧ x < i
⊢ ∃ j, j ∈ upperBounds (Iio i) ∧ j < i
Theorem: sq_abs
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [sq] using abs_mul_abs_self x
state_before: β : Type ?u.255421
A : Type ?u.255424
G : Type ?u.255427
M : Type ?u.255430
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y x : R
⊢ abs x ^ 2 = x ^ 2
Theorem: HasDerivAtFilter.sum
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa [ContinuousLinearMap.sum_apply] using (HasFDerivAtFilter.sum h).hasDerivAtFilter
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 : Filter 𝕜
ι : Type u_1
u : Finset ι
A : ι → 𝕜 → F
A' : ι → F
h : ∀ (i : ι), i ∈ u → HasDerivAtFilter (A i) (A' i) x L
⊢ HasDerivAtFilter (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x L
Theorem: ae_eq_const_or_norm_set_integral_lt_of_norm_le_const
File: Mathlib/Analysis/Convex/Integral.lean

tactic: haveI := Fact.mk ht.lt_top
state_before: α : Type u_2
E : Type u_1
F : Type ?u.2692874
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : ↑↑μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂Measure.restrict μ t, ‖f x‖ ≤ C
⊢ f =ᶠ[ae (Measure.restrict μ t)] const α (⨍ (x : α) in t, f x ∂μ) ∨
    ‖∫ (x : α) in t, f x ∂μ‖ < ENNReal.toReal (↑↑μ t) * C

tactic: rw [← restrict_apply_univ]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.2692874
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : ↑↑μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂Measure.restrict μ t, ‖f x‖ ≤ C
this : Fact (↑↑μ t < ⊤)
⊢ f =ᶠ[ae (Measure.restrict μ t)] const α (⨍ (x : α) in t, f x ∂μ) ∨
    ‖∫ (x : α) in t, f x ∂μ‖ < ENNReal.toReal (↑↑μ t) * C

tactic: exact ae_eq_const_or_norm_integral_lt_of_norm_le_const h_le
state_before: α : Type u_2
E : Type u_1
F : Type ?u.2692874
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : StrictConvexSpace ℝ E
ht : ↑↑μ t ≠ ⊤
h_le : ∀ᵐ (x : α) ∂Measure.restrict μ t, ‖f x‖ ≤ C
this : Fact (↑↑μ t < ⊤)
⊢ f =ᶠ[ae (Measure.restrict μ t)] const α (⨍ (x : α) in t, f x ∂μ) ∨
    ‖∫ (x : α) in t, f x ∂μ‖ < ENNReal.toReal (↑↑(Measure.restrict μ t) univ) * C
Theorem: Set.Ioc_union_Ioi'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)

tactic: simp_rw [mem_union, mem_Ioc, mem_Ioi, min_lt_iff]
state_before: case h
α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Ioc a b ∪ Ioi c ↔ x ∈ Ioi (min a c)

tactic: by_cases hc : c < x
state_before: case h
α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ a < x ∧ x ≤ b ∨ c < x ↔ a < x ∨ c < x

tactic: simp only [hc, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : c < x
⊢ a < x ∧ x ≤ b ∨ c < x ↔ a < x ∨ c < x

tactic: have hxb : x ≤ b := (le_of_not_gt hc).trans h₁
state_before: case neg
α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c < x
⊢ a < x ∧ x ≤ b ∨ c < x ↔ a < x ∨ c < x

tactic: simp only [hxb, and_true]
state_before: case neg
α : Type u_1
β : Type ?u.86199
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c < x
hxb : x ≤ b
⊢ a < x ∧ x ≤ b ∨ c < x ↔ a < x ∨ c < x