tasksource/leandojo huggingface dataset:
Theorem: exists_Icc_mem_subset_of_mem_nhds
File: Mathlib/Topology/Order/Basic.lean

tactic: rcases exists_Icc_mem_subset_of_mem_nhdsWithin_Iic (nhdsWithin_le_nhds hs) with
  ⟨b, hba, hb_nhds, hbs⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝 a
⊢ ∃ b c, a ∈ Icc b c ∧ Icc b c ∈ 𝓝 a ∧ Icc b c ⊆ s

tactic: rcases exists_Icc_mem_subset_of_mem_nhdsWithin_Ici (nhdsWithin_le_nhds hs) with
  ⟨c, hac, hc_nhds, hcs⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝 a
b : α
hba : b ≤ a
hb_nhds : Icc b a ∈ 𝓝[Iic a] a
hbs : Icc b a ⊆ s
⊢ ∃ b c, a ∈ Icc b c ∧ Icc b c ∈ 𝓝 a ∧ Icc b c ⊆ s

tactic: refine' ⟨b, c, ⟨hba, hac⟩, _⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝 a
b : α
hba : b ≤ a
hb_nhds : Icc b a ∈ 𝓝[Iic a] a
hbs : Icc b a ⊆ s
c : α
hac : a ≤ c
hc_nhds : Icc a c ∈ 𝓝[Ici a] a
hcs : Icc a c ⊆ s
⊢ ∃ b c, a ∈ Icc b c ∧ Icc b c ∈ 𝓝 a ∧ Icc b c ⊆ s

tactic: rw [← Icc_union_Icc_eq_Icc hba hac, ← nhds_left_sup_nhds_right]
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝 a
b : α
hba : b ≤ a
hb_nhds : Icc b a ∈ 𝓝[Iic a] a
hbs : Icc b a ⊆ s
c : α
hac : a ≤ c
hc_nhds : Icc a c ∈ 𝓝[Ici a] a
hcs : Icc a c ⊆ s
⊢ Icc b c ∈ 𝓝 a ∧ Icc b c ⊆ s

tactic: exact ⟨union_mem_sup hb_nhds hc_nhds, union_subset hbs hcs⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
s : Set α
hs : s ∈ 𝓝 a
b : α
hba : b ≤ a
hb_nhds : Icc b a ∈ 𝓝[Iic a] a
hbs : Icc b a ⊆ s
c : α
hac : a ≤ c
hc_nhds : Icc a c ∈ 𝓝[Ici a] a
hcs : Icc a c ⊆ s
⊢ Icc b a ∪ Icc a c ∈ 𝓝[Iic a] a ⊔ 𝓝[Ici a] a ∧ Icc b a ∪ Icc a c ⊆ s
Theorem: Mathlib.Meta.NormNum.isRat_pow
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro rfl ⟨_, rfl⟩ ⟨rfl⟩ (rfl : an ^ b = _) (rfl : ad ^ b = _)
state_before: α : Type u_1
inst✝ : Ring α
f : α → ℕ → α
a : α
an cn : ℤ
ad b b' cd : ℕ
⊢ f = HPow.hPow → IsRat a an ad → IsNat b b' → Int.pow an b' = cn → Nat.pow ad b' = cd → IsRat (f a b) cn cd

tactic: have := invertiblePow (ad:α) b
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: rw [← Nat.cast_pow] at this
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible (↑ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: use this
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: simp [invOf_pow, Commute.mul_pow]
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ (↑an * ⅟↑ad) ^ b = ↑(an ^ b) * ⅟↑(ad ^ b)
Theorem: MonoidHom.comp_mul
File: Mathlib/Algebra/Hom/Group.lean

tactic: ext
state_before: α : Type ?u.215866
β : Type ?u.215869
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.215881
H : Type ?u.215884
F : Type ?u.215887
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
⊢ comp g (f₁ * f₂) = comp g f₁ * comp g f₂

tactic: simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
state_before: case h
α : Type ?u.215866
β : Type ?u.215869
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.215881
H : Type ?u.215884
F : Type ?u.215887
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
x✝ : M
⊢ ↑(comp g (f₁ * f₂)) x✝ = ↑(comp g f₁ * comp g f₂) x✝
Theorem: PiLp.dist_eq_iSup
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: dsimp [dist]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.22498
𝕜' : Type ?u.22501
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.22514
inst✝¹ : Fintype ι
inst✝ : (i : ι) → Dist (α i)
f g : PiLp ⊤ α
⊢ dist f g = ⨆ (i : ι), dist (f i) (g i)

tactic: exact if_neg ENNReal.top_ne_zero
state_before: p : ℝ≥0∞
𝕜 : Type ?u.22498
𝕜' : Type ?u.22501
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.22514
inst✝¹ : Fintype ι
inst✝ : (i : ι) → Dist (α i)
f g : PiLp ⊤ α
⊢ (if ⊤ = 0 then ↑(Finset.card (Finite.toFinset (_ : Set.Finite {i | f i ≠ g i})))
    else if ⊤ = ⊤ then ⨆ (i : ι), dist (f i) (g i) else (∑ i : ι, dist (f i) (g i) ^ 0) ^ (1 / 0)) =
    ⨆ (i : ι), dist (f i) (g i)
Theorem: Turing.TM1to1.supportsStmt_write
File: Mathlib/Computability/TuringMachine.lean

tactic: induction' l with _ l IH <;> simp only [write, SupportsStmt, *]
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
l : List Bool
q : Stmt Bool Λ' σ
⊢ SupportsStmt S (write l q) = SupportsStmt S q
Theorem: MeasureTheory.extend_mono
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' le_iInf _
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
⊢ extend m s₁ ≤ extend m s₂

tactic: intro h₂
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
⊢ ∀ (i : (fun s => MeasurableSet s) s₂), extend m s₁ ≤ m s₂ i

tactic: have :=
  extend_union MeasurableSet.empty m0 MeasurableSet.iUnion mU disjoint_sdiff_self_right h₁
    (h₂.diff h₁)
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => MeasurableSet s) s₂
⊢ extend m s₁ ≤ m s₂ h₂

tactic: rw [union_diff_cancel hs] at this
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => MeasurableSet s) s₂
this : extend m (s₁ ∪ s₂ \ s₁) = extend m s₁ + extend m (s₂ \ s₁)
⊢ extend m s₁ ≤ m s₂ h₂

tactic: rw [← extend_eq m]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => MeasurableSet s) s₂
this : extend m s₂ = extend m s₁ + extend m (s₂ \ s₁)
⊢ extend m s₁ ≤ m s₂ h₂

tactic: exact le_iff_exists_add.2 ⟨_, this⟩
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ (i : ℕ), f i) (_ : MeasurableSet (⋃ (b : ℕ), f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => MeasurableSet s) s₂
this : extend m s₂ = extend m s₁ + extend m (s₂ \ s₁)
⊢ extend m s₁ ≤ extend m s₂
Theorem: Set.prod_inter_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.13537
δ : Type ?u.13540
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂)

tactic: simp [and_assoc, and_left_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.13537
δ : Type ?u.13540
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ ↔ (x, y) ∈ (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂)
Theorem: ZMod.int_cast_zmod_eq_zero_iff_dvd
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Int.cast_zero, ZMod.int_cast_eq_int_cast_iff, Int.modEq_zero_iff_dvd]
state_before: a : ℤ
b : ℕ
⊢ ↑a = 0 ↔ ↑b ∣ a
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_add
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_def, neg_def, sub_sub_sub, sub_zero]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c : X ⟶ Y
⊢ a - b + c = a - (b - c)
Theorem: inf_sdiff_eq_bot_iff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← disjoint_iff]
state_before: α : Type u
β : Type ?u.14724
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ z ⊓ y \ x = ⊥ ↔ z ≤ x

tactic: exact disjoint_sdiff_iff_le hz hx
state_before: α : Type u
β : Type ?u.14724
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ Disjoint z (y \ x) ↔ z ≤ x
Theorem: Complex.sin_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_left_inj' I_ne_zero, ← sinh_mul_I, add_mul, add_mul, mul_right_comm, ← sinh_mul_I,
  mul_assoc, ← sinh_mul_I, ← cosh_mul_I, ← cosh_mul_I, sinh_add]
state_before: x y : ℂ
⊢ sin (x + y) = sin x * cos y + cos x * sin y
Theorem: Complex.isCauSeq_abs_exp
File: Mathlib/Data/Complex/Exponential.lean

tactic: rwa [div_lt_iff hn0, one_mul]
state_before: z : ℂ
n : ℕ
hn : ↑abs z < ↑n
hn0 : 0 < ↑n
⊢ ↑abs z / ↑n < 1

tactic: rw [abs_abs, abs_abs, Nat.factorial_succ, pow_succ, mul_comm m.succ, Nat.cast_mul, ← div_div,
  mul_div_assoc, mul_div_right_comm, map_mul, map_div₀, abs_cast_nat]
state_before: z : ℂ
n : ℕ
hn : ↑abs z < ↑n
hn0 : 0 < ↑n
m : ℕ
hm : n ≤ m
⊢ abs' (↑abs (z ^ Nat.succ m / ↑(Nat.factorial (Nat.succ m)))) ≤ ↑abs z / ↑n * abs' (↑abs (z ^ m / ↑(Nat.factorial m)))

tactic: gcongr
state_before: z : ℂ
n : ℕ
hn : ↑abs z < ↑n
hn0 : 0 < ↑n
m : ℕ
hm : n ≤ m
⊢ ↑abs z / ↑(Nat.succ m) * ↑abs (z ^ m / ↑(Nat.factorial m)) ≤ ↑abs z / ↑n * ↑abs (z ^ m / ↑(Nat.factorial m))

tactic: exact le_trans hm (Nat.le_succ _)
state_before: case h.h.h
z : ℂ
n : ℕ
hn : ↑abs z < ↑n
hn0 : 0 < ↑n
m : ℕ
hm : n ≤ m
⊢ n ≤ Nat.succ m
Theorem: List.rotate_append_length_eq
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate']
state_before: α : Type u
l l' : List α
⊢ rotate (l ++ l') (length l) = l' ++ l

tactic: induction l generalizing l'
state_before: α : Type u
l l' : List α
⊢ rotate' (l ++ l') (length l) = l' ++ l

tactic: simp
state_before: case nil
α : Type u
l' : List α
⊢ rotate' ([] ++ l') (length []) = l' ++ []

tactic: simp_all [rotate']
state_before: case cons
α : Type u
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (l' : List α), rotate' (tail✝ ++ l') (length tail✝) = l' ++ tail✝
l' : List α
⊢ rotate' (head✝ :: tail✝ ++ l') (length (head✝ :: tail✝)) = l' ++ head✝ :: tail✝
Theorem: List.card_le_card_cons
File: Mathlib/Data/List/Card.lean

tactic: cases Decidable.em (a ∈ as) with
| inl h => simp [h, Nat.le_refl]
| inr h => simp [h, Nat.le_succ]
state_before: α : Type u_1
β : Sort ?u.22986
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
⊢ card as ≤ card (a :: as)

tactic: simp [h, Nat.le_refl]
state_before: case inl
α : Type u_1
β : Sort ?u.22986
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : a ∈ as
⊢ card as ≤ card (a :: as)

tactic: simp [h, Nat.le_succ]
state_before: case inr
α : Type u_1
β : Sort ?u.22986
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : ¬a ∈ as
⊢ card as ≤ card (a :: as)
Theorem: QuotientGroup.isOpenMap_coe
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: intro s s_op
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : Subgroup.Normal N
⊢ IsOpenMap mk

tactic: change IsOpen (((↑) : G → G ⧸ N) ⁻¹' ((↑) '' s))
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : Subgroup.Normal N
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk '' s)

tactic: rw [QuotientGroup.preimage_image_mk N s]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : Subgroup.Normal N
s : Set G
s_op : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))

tactic: exact isOpen_iUnion fun n => (continuous_mul_right _).isOpen_preimage s s_op
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
N : Subgroup G
n : Subgroup.Normal N
s : Set G
s_op : IsOpen s
⊢ IsOpen (⋃ (x : { x // x ∈ N }), (fun y => y * ↑x) ⁻¹' s)
Theorem: MvPolynomial.supported_le_supported_iff
File: Mathlib/Data/MvPolynomial/Supported.lean

tactic: constructor
state_before: σ : Type u_1
τ : Type ?u.129141
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ supported R s ≤ supported R t ↔ s ⊆ t

tactic: intro h i
state_before: case mp
σ : Type u_1
τ : Type ?u.129141
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ supported R s ≤ supported R t → s ⊆ t

tactic: simpa using @h (X i)
state_before: case mp
σ : Type u_1
τ : Type ?u.129141
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
h : supported R s ≤ supported R t
i : σ
⊢ i ∈ s → i ∈ t

tactic: exact supported_mono
state_before: case mpr
σ : Type u_1
τ : Type ?u.129141
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ s ⊆ t → supported R s ≤ supported R t
Theorem: div_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.36695
G : Type ?u.36698
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = a / (b / c)
Theorem: partialSups_mono
File: Mathlib/Order/PartialSups.lean

tactic: rintro f g h n
state_before: α : Type u_1
inst✝ : SemilatticeSup α
⊢ Monotone partialSups

tactic: induction' n with n ih
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f g : ℕ → α
h : f ≤ g
n : ℕ
⊢ ↑(partialSups f) n ≤ ↑(partialSups g) n

tactic: exact h 0
state_before: case zero
α : Type u_1
inst✝ : SemilatticeSup α
f g : ℕ → α
h : f ≤ g
⊢ ↑(partialSups f) Nat.zero ≤ ↑(partialSups g) Nat.zero

tactic: exact sup_le_sup ih (h _)
state_before: case succ
α : Type u_1
inst✝ : SemilatticeSup α
f g : ℕ → α
h : f ≤ g
n : ℕ
ih : ↑(partialSups f) n ≤ ↑(partialSups g) n
⊢ ↑(partialSups f) (Nat.succ n) ≤ ↑(partialSups g) (Nat.succ n)
Theorem: Option.join_map_eq_map_join
File: Std/Data/Option/Lemmas.lean

tactic: cases x <;> simp
state_before: α : Type u_1
β : Type u_2
f : α → β
x : Option (Option α)
⊢ join (Option.map (Option.map f) x) = Option.map f (join x)
Theorem: Primrec.option_orElse
File: Mathlib/Computability/Primrec.lean

tactic: cases o₁ <;> cases o₂ <;> rfl
state_before: α : Type u_1
β : Type ?u.139430
γ : Type ?u.139433
δ : Type ?u.139436
σ : Type ?u.139439
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
x✝ : Option α × Option α
o₁ o₂ : Option α
⊢ (Option.casesOn (o₁, o₂).fst (o₁, o₂).snd fun b => ((o₁, o₂), b).fst.fst) =
    (fun x x_1 => HOrElse.hOrElse x fun x => x_1) (o₁, o₂).fst (o₁, o₂).snd
Theorem: CategoryTheory.Limits.biproduct.components_matrix
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext
state_before: J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : ⨁ f ⟶ ⨁ g
⊢ (matrix fun j k => components m j k) = m

tactic: simp [biproduct.components]
state_before: case w.w
J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : ⨁ f ⟶ ⨁ g
j✝¹ : J
j✝ : K
⊢ (ι (fun j => f j) j✝¹ ≫ matrix fun j k => components m j k) ≫ π (fun k => g k) j✝ =
    (ι (fun j => f j) j✝¹ ≫ m) ≫ π (fun k => g k) j✝
Theorem: Subgroup.smul_inf
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: simp [SetLike.ext_iff, mem_pointwise_smul_iff_inv_smul_mem]
state_before: α : Type u_2
G : Type u_1
A : Type ?u.151816
S✝ : Type ?u.151819
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Group α
inst✝ : MulDistribMulAction α G
a : α
S T : Subgroup G
⊢ a • (S ⊓ T) = a • S ⊓ a • T
Theorem: Finset.filter_ne
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type ?u.412614
β : Type u_1
γ : Type ?u.412620
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b : β
⊢ filter (fun a => b ≠ a) s = erase s b

tactic: simp only [mem_filter, mem_erase, Ne.def, decide_not, Bool.not_eq_true', decide_eq_false_iff_not]
state_before: case a
α : Type ?u.412614
β : Type u_1
γ : Type ?u.412620
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ filter (fun a => b ≠ a) s ↔ a✝ ∈ erase s b

tactic: tauto
state_before: case a
α : Type ?u.412614
β : Type u_1
γ : Type ?u.412620
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ s ∧ ¬b = a✝ ↔ ¬a✝ = b ∧ a✝ ∈ s
Theorem: Finset.mem_memberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp_rw [memberSubfamily, mem_image, mem_filter]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ s ∈ memberSubfamily a 𝒜 ↔ insert a s ∈ 𝒜 ∧ ¬a ∈ s

tactic: refine' ⟨_, fun h => ⟨insert a s, ⟨h.1, by simp⟩, erase_insert h.2⟩⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ (∃ a_1, (a_1 ∈ 𝒜 ∧ a ∈ a_1) ∧ erase a_1 a = s) ↔ insert a s ∈ 𝒜 ∧ ¬a ∈ s

tactic: rintro ⟨s, ⟨hs1, hs2⟩, rfl⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ (∃ a_1, (a_1 ∈ 𝒜 ∧ a ∈ a_1) ∧ erase a_1 a = s) → insert a s ∈ 𝒜 ∧ ¬a ∈ s

tactic: rw [insert_erase hs2]
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
a : α
s : Finset α
hs1 : s ∈ 𝒜
hs2 : a ∈ s
⊢ insert a (erase s a) ∈ 𝒜 ∧ ¬a ∈ erase s a

tactic: exact ⟨hs1, not_mem_erase _ _⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
a : α
s : Finset α
hs1 : s ∈ 𝒜
hs2 : a ∈ s
⊢ s ∈ 𝒜 ∧ ¬a ∈ erase s a

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
h : insert a s ∈ 𝒜 ∧ ¬a ∈ s
⊢ a ∈ insert a s
Theorem: MeasureTheory.OuterMeasure.iSup_sInfGen_nonempty
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rcases t.eq_empty_or_nonempty with (rfl | ht)
state_before: α : Type u_1
m : Set (OuterMeasure α)
h : Set.Nonempty m
t : Set α
⊢ (⨆ (_ : Set.Nonempty t), sInfGen m t) = ⨅ (μ : OuterMeasure α) (_ : μ ∈ m), ↑μ t

tactic: rcases h with ⟨μ, hμ⟩
state_before: case inl
α : Type u_1
m : Set (OuterMeasure α)
h : Set.Nonempty m
⊢ (⨆ (_ : Set.Nonempty ∅), sInfGen m ∅) = ⨅ (μ : OuterMeasure α) (_ : μ ∈ m), ↑μ ∅

tactic: rw [eq_false Set.not_nonempty_empty, iSup_false, eq_comm]
state_before: case inl.intro
α : Type u_1
m : Set (OuterMeasure α)
μ : OuterMeasure α
hμ : μ ∈ m
⊢ (⨆ (_ : Set.Nonempty ∅), sInfGen m ∅) = ⨅ (μ : OuterMeasure α) (_ : μ ∈ m), ↑μ ∅

tactic: simp_rw [empty']
state_before: case inl.intro
α : Type u_1
m : Set (OuterMeasure α)
μ : OuterMeasure α
hμ : μ ∈ m
⊢ (⨅ (μ : OuterMeasure α) (_ : μ ∈ m), ↑μ ∅) = ⊥

tactic: apply bot_unique
state_before: case inl.intro
α : Type u_1
m : Set (OuterMeasure α)
μ : OuterMeasure α
hμ : μ ∈ m
⊢ (⨅ (μ : OuterMeasure α) (_ : μ ∈ m), 0) = ⊥

tactic: refine' iInf_le_of_le μ (iInf_le _ hμ)
state_before: case inl.intro.h
α : Type u_1
m : Set (OuterMeasure α)
μ : OuterMeasure α
hμ : μ ∈ m
⊢ (⨅ (μ : OuterMeasure α) (_ : μ ∈ m), 0) ≤ ⊥

tactic: simp [ht, sInfGen_def]
state_before: case inr
α : Type u_1
m : Set (OuterMeasure α)
h : Set.Nonempty m
t : Set α
ht : Set.Nonempty t
⊢ (⨆ (_ : Set.Nonempty t), sInfGen m t) = ⨅ (μ : OuterMeasure α) (_ : μ ∈ m), ↑μ t
Theorem: CategoryTheory.GrothendieckTopology.sheafify_hom_ext
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: apply J.plus_hom_ext _ _ hQ
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 : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ η = γ

tactic: apply J.plus_hom_ext _ _ hQ
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 : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ toPlus J (plusObj J P) ≫ η = toPlus J (plusObj J P) ≫ γ

tactic: rw [← Category.assoc, ← Category.assoc, ← plusMap_toPlus]
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 : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ toPlus J P ≫ toPlus J (plusObj J P) ≫ η = toPlus J P ≫ toPlus J (plusObj J P) ≫ γ

tactic: exact h
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 : Cᵒᵖ ⥤ D
η γ : sheafify J P ⟶ Q
hQ : Presheaf.IsSheaf J Q
h : toSheafify J P ≫ η = toSheafify J P ≫ γ
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ η = (toPlus J P ≫ plusMap J (toPlus J P)) ≫ γ
Theorem: padicValNat.mul
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: exact_mod_cast @padicValRat.mul p _ a b
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
⊢ a ≠ 0 → b ≠ 0 → padicValNat p (a * b) = padicValNat p a + padicValNat p b
Theorem: ENNReal.pow_lt_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [lt_top_iff_ne_top] using pow_ne_top
state_before: α : Type ?u.96829
β : Type ?u.96832
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a < ⊤ → ∀ (n : ℕ), a ^ n < ⊤
Theorem: Stream'.WSeq.liftRel_nil
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [liftRel_destruct_iff]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
⊢ LiftRel R nil nil

tactic: simp [-liftRel_pure_left, -liftRel_pure_right]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct nil) (destruct nil)