tasksource/leandojo huggingface dataset:
Theorem: Filter.mem_interior
File: Mathlib/Topology/Filter.lean

tactic: rw [mem_interior_iff_mem_nhds, mem_nhds_iff]
state_before: ι : Sort ?u.15646
α : Type u_1
β : Type ?u.15652
X : Type ?u.15655
Y : Type ?u.15658
s : Set (Filter α)
l : Filter α
⊢ l ∈ interior s ↔ ∃ t, t ∈ l ∧ Iic (𝓟 t) ⊆ s
Theorem: MeasureTheory.TendstoInMeasure.aeMeasurable
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

tactic: obtain ⟨ns, hns⟩ := h_tendsto.exists_seq_tendsto_ae'
state_before: α : Type u_2
ι : Type u_1
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : BorelSpace E
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
f : ι → α → E
g : α → E
hf : ∀ (n : ι), AEMeasurable (f n)
h_tendsto : TendstoInMeasure μ f u g
⊢ AEMeasurable g

tactic: exact aemeasurable_of_tendsto_metrizable_ae atTop (fun n => hf (ns n)) hns
state_before: case intro
α : Type u_2
ι : Type u_1
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : BorelSpace E
u : Filter ι
inst✝¹ : NeBot u
inst✝ : IsCountablyGenerated u
f : ι → α → E
g : α → E
hf : ∀ (n : ι), AEMeasurable (f n)
h_tendsto : TendstoInMeasure μ f u g
ns : ℕ → ι
hns : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
⊢ AEMeasurable g
Theorem: Set.zero_mem_centralizer
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: simp [mem_centralizer_iff]
state_before: M : Type u_1
S T : Set M
inst✝ : MulZeroClass M
⊢ 0 ∈ centralizer S
Theorem: LocalizedModule.mk_smul_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: dsimp only [HSMul.hSMul, SMul.smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
m : M
s t : { x // x ∈ S }
⊢ Localization.mk r s • mk m t = mk (r • m) (s * t)

tactic: rw [Localization.liftOn_mk, liftOn_mk]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
m : M
s t : { x // x ∈ S }
⊢ Localization.liftOn (Localization.mk r s)
      (fun r s =>
        liftOn (mk m t) (fun p => mk (SMul.smul r p.fst) (s * p.snd))
          (_ :
            ∀ (p p' : M × { x // x ∈ S }),
              p ≈ p' → (fun p => mk (r • p.fst) (s * p.snd)) p = (fun p => mk (r • p.fst) (s * p.snd)) p'))
      (_ :
        ∀ {a c : R} {b d : { x // x ∈ S }},
          ↑(Localization.r S) (a, b) (c, d) →
            (fun r s =>
                  liftOn (mk m t) (fun p => mk (r • p.fst) (s * p.snd))
                    (_ :
                      ∀ (p p' : M × { x // x ∈ S }),
                        p ≈ p' → (fun p => mk (r • p.fst) (s * p.snd)) p = (fun p => mk (r • p.fst) (s * p.snd)) p'))
                a b =
              (fun r s =>
                  liftOn (mk m t) (fun p => mk (r • p.fst) (s * p.snd))
                    (_ :
                      ∀ (p p' : M × { x // x ∈ S }),
                        p ≈ p' → (fun p => mk (r • p.fst) (s * p.snd)) p = (fun p => mk (r • p.fst) (s * p.snd)) p'))
                c d) =
    mk (SMul.smul r m) (s * t)
Theorem: MeasureTheory.SimpleFunc.map_restrict_of_zero
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [hs, Set.indicator_comp_of_zero hg]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
δ : Type ?u.809158
inst✝² : MeasurableSpace α
K : Type ?u.809164
inst✝¹ : Zero β
inst✝ : Zero γ
g : β → γ
hg : g 0 = 0
f : α →ₛ β
s : Set α
x : α
hs : MeasurableSet s
⊢ ↑(map g (restrict f s)) x = ↑(restrict (map g f) s) x

tactic: simp [restrict_of_not_measurable hs, hg]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
δ : Type ?u.809158
inst✝² : MeasurableSpace α
K : Type ?u.809164
inst✝¹ : Zero β
inst✝ : Zero γ
g : β → γ
hg : g 0 = 0
f : α →ₛ β
s : Set α
x : α
hs : ¬MeasurableSet s
⊢ ↑(map g (restrict f s)) x = ↑(restrict (map g f) s) x
Theorem: Finset.subset_image_iff
File: Mathlib/Data/Finset/Image.lean

tactic: constructor
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
⊢ ↑t ⊆ f '' s ↔ ∃ s', ↑s' ⊆ s ∧ image f s' = t

tactic: swap
state_before: case mp
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
⊢ ↑t ⊆ f '' s → ∃ s', ↑s' ⊆ s ∧ image f s' = t

case mpr
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
⊢ (∃ s', ↑s' ⊆ s ∧ image f s' = t) → ↑t ⊆ f '' s

tactic: intro h
state_before: case mp
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
⊢ ↑t ⊆ f '' s → ∃ s', ↑s' ⊆ s ∧ image f s' = t

tactic: letI : CanLift β s (f ∘ (↑)) fun y => y ∈ f '' s := ⟨fun y ⟨x, hxt, hy⟩ => ⟨⟨x, hxt⟩, hy⟩⟩
state_before: case mp
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
h : ↑t ⊆ f '' s
⊢ ∃ s', ↑s' ⊆ s ∧ image f s' = t

tactic: lift t to Finset s using h
state_before: case mp
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
h : ↑t ⊆ f '' s
this : CanLift β (↑s) (f ∘ Subtype.val) fun y => y ∈ f '' s :=
  { prf := (_ : ∀ (y : β), y ∈ f '' s → ∃ y_1, (f ∘ Subtype.val) y_1 = y) }
⊢ ∃ s', ↑s' ⊆ s ∧ image f s' = t

tactic: refine' ⟨t.map (Embedding.subtype _), map_subtype_subset _, _⟩
state_before: case mp.intro
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
f : α → β
this : CanLift β (↑s) (f ∘ Subtype.val) fun y => y ∈ f '' s :=
  { prf := (_ : ∀ (y : β), y ∈ f '' s → ∃ y_1, (f ∘ Subtype.val) y_1 = y) }
t : Finset ↑s
⊢ ∃ s', ↑s' ⊆ s ∧ image f s' = image (f ∘ Subtype.val) t

tactic: ext y
state_before: case mp.intro
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
f : α → β
this : CanLift β (↑s) (f ∘ Subtype.val) fun y => y ∈ f '' s :=
  { prf := (_ : ∀ (y : β), y ∈ f '' s → ∃ y_1, (f ∘ Subtype.val) y_1 = y) }
t : Finset ↑s
⊢ image f (map (Embedding.subtype fun x => x ∈ s) t) = image (f ∘ Subtype.val) t

tactic: simp
state_before: case mp.intro.a
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
f : α → β
this : CanLift β (↑s) (f ∘ Subtype.val) fun y => y ∈ f '' s :=
  { prf := (_ : ∀ (y : β), y ∈ f '' s → ∃ y_1, (f ∘ Subtype.val) y_1 = y) }
t : Finset ↑s
y : β
⊢ y ∈ image f (map (Embedding.subtype fun x => x ∈ s) t) ↔ y ∈ image (f ∘ Subtype.val) t

tactic: rintro ⟨t, ht, rfl⟩
state_before: case mpr
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
t : Finset β
f : α → β
⊢ (∃ s', ↑s' ⊆ s ∧ image f s' = t) → ↑t ⊆ f '' s

tactic: rw [coe_image]
state_before: case mpr.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
f : α → β
t : Finset α
ht : ↑t ⊆ s
⊢ ↑(image f t) ⊆ f '' s

tactic: exact Set.image_subset f ht
state_before: case mpr.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.140906
inst✝ : DecidableEq β
s : Set α
f : α → β
t : Finset α
ht : ↑t ⊆ s
⊢ f '' ↑t ⊆ f '' s
Theorem: OrderIso.mulRight_symm
File: Mathlib/Algebra/Order/Group/OrderIso.lean

tactic: ext x
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a : α
⊢ symm (mulRight a) = mulRight a⁻¹

tactic: rfl
state_before: case h.h
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c d a x : α
⊢ ↑(symm (mulRight a)) x = ↑(mulRight a⁻¹) x
Theorem: Prime.exists_mem_multiset_dvd
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.8870
γ : Type ?u.8873
δ : Type ?u.8876
inst✝ : CommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : p ∣ Multiset.prod s → ∃ a, a ∈ s ∧ p ∣ a
h : p ∣ Multiset.prod (a ::ₘ s)
⊢ p ∣ a * Multiset.prod s
Theorem: Finsupp.toFreeAbelianGroup_comp_singleAddHom
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: ext
state_before: X : Type u_1
x : X
⊢ AddMonoidHom.comp toFreeAbelianGroup (singleAddHom x) =
    ↑(AddMonoidHom.flip (smulAddHom ℤ (FreeAbelianGroup X))) (of x)

tactic: simp only [AddMonoidHom.coe_comp, Finsupp.singleAddHom_apply, Function.comp_apply, one_smul,
  toFreeAbelianGroup, Finsupp.liftAddHom_apply_single]
state_before: case h1
X : Type u_1
x : X
⊢ ↑(AddMonoidHom.comp toFreeAbelianGroup (singleAddHom x)) 1 =
    ↑(↑(AddMonoidHom.flip (smulAddHom ℤ (FreeAbelianGroup X))) (of x)) 1
Theorem: Real.Angle.toReal_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: nth_rw 1 [← toReal_zero]
state_before: θ : Angle
⊢ toReal θ = 0 ↔ θ = 0

tactic: exact toReal_inj
state_before: θ : Angle
⊢ toReal θ = toReal 0 ↔ θ = 0
Theorem: cross_dot_cross
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: simp_rw [cross_apply, vec3_dotProduct]
state_before: R : Type u_1
inst✝ : CommRing R
u v w x : Fin 3 → R
⊢ ↑(↑crossProduct u) v ⬝ᵥ ↑(↑crossProduct w) x = u ⬝ᵥ w * v ⬝ᵥ x - u ⬝ᵥ x * v ⬝ᵥ w

tactic: norm_num
state_before: R : Type u_1
inst✝ : CommRing R
u v w x : Fin 3 → R
⊢ vecCons (u 1 * v 2 - u 2 * v 1) ![u 2 * v 0 - u 0 * v 2, u 0 * v 1 - u 1 * v 0] 0 *
          vecCons (w 1 * x 2 - w 2 * x 1) ![w 2 * x 0 - w 0 * x 2, w 0 * x 1 - w 1 * x 0] 0 +
        vecCons (u 1 * v 2 - u 2 * v 1) ![u 2 * v 0 - u 0 * v 2, u 0 * v 1 - u 1 * v 0] 1 *
          vecCons (w 1 * x 2 - w 2 * x 1) ![w 2 * x 0 - w 0 * x 2, w 0 * x 1 - w 1 * x 0] 1 +
      vecCons (u 1 * v 2 - u 2 * v 1) ![u 2 * v 0 - u 0 * v 2, u 0 * v 1 - u 1 * v 0] 2 *
        vecCons (w 1 * x 2 - w 2 * x 1) ![w 2 * x 0 - w 0 * x 2, w 0 * x 1 - w 1 * x 0] 2 =
    (u 0 * w 0 + u 1 * w 1 + u 2 * w 2) * (v 0 * x 0 + v 1 * x 1 + v 2 * x 2) -
      (u 0 * x 0 + u 1 * x 1 + u 2 * x 2) * (v 0 * w 0 + v 1 * w 1 + v 2 * w 2)

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
u v w x : Fin 3 → R
⊢ (u 1 * v 2 - u 2 * v 1) * (w 1 * x 2 - w 2 * x 1) + (u 2 * v 0 - u 0 * v 2) * (w 2 * x 0 - w 0 * x 2) +
      (u 0 * v 1 - u 1 * v 0) * (w 0 * x 1 - w 1 * x 0) =
    (u 0 * w 0 + u 1 * w 1 + u 2 * w 2) * (v 0 * x 0 + v 1 * x 1 + v 2 * x 2) -
      (u 0 * x 0 + u 1 * x 1 + u 2 * x 2) * (v 0 * w 0 + v 1 * w 1 + v 2 * w 2)
Theorem: CategoryTheory.NatIso.cancel_natIso_inv_left
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [cancel_epi, refl]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
α : F ≅ G
X : C
Z : D
g g' : F.obj X ⟶ Z
⊢ α.inv.app X ≫ g = α.inv.app X ≫ g' ↔ g = g'
Theorem: NNReal.count_const_le_le_of_tsum_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [show (fun i => ε ≤ a i) = fun i => (ε : ℝ≥0∞) ≤ ((↑) ∘ a) i by
    funext i
    simp only [ENNReal.coe_le_coe, Function.comp]]
state_before: α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ ↑↑count {i | ε ≤ a i} ≤ ↑c / ↑ε

tactic: apply
  ENNReal.count_const_le_le_of_tsum_le (measurable_coe_nnreal_ennreal.comp a_mble) _
    (by exact_mod_cast ε_ne_zero) (@ENNReal.coe_ne_top ε)
state_before: α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ ↑↑count {i | ↑ε ≤ (ENNReal.some ∘ a) i} ≤ ↑c / ↑ε

tactic: convert ENNReal.coe_le_coe.mpr tsum_le_c
state_before: α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ (∑' (i : α), (ENNReal.some ∘ a) i) ≤ ↑c

tactic: erw [ENNReal.tsum_coe_eq a_summable.hasSum]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ (∑' (i : α), (ENNReal.some ∘ a) i) = ↑(∑' (i : α), a i)

tactic: funext i
state_before: α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ (fun i => ε ≤ a i) = fun i => ↑ε ≤ (ENNReal.some ∘ a) i

tactic: simp only [ENNReal.coe_le_coe, Function.comp]
state_before: case h
α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
i : α
⊢ (ε ≤ a i) = (↑ε ≤ (ENNReal.some ∘ a) i)

tactic: exact_mod_cast ε_ne_zero
state_before: α : Type u_1
β : Type ?u.1696412
γ : Type ?u.1696415
δ : Type ?u.1696418
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0
a_mble : Measurable a
a_summable : Summable a
c : ℝ≥0
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0
ε_ne_zero : ε ≠ 0
⊢ ↑ε ≠ 0
Theorem: Nat.bit_eq_zero
File: Mathlib/Data/Nat/Bitwise.lean

tactic: cases b <;> simp [Nat.bit0_eq_zero, Nat.bit1_ne_zero]
state_before: n : ℕ
b : Bool
⊢ bit b n = 0 ↔ n = 0 ∧ b = false
Theorem: Nat.range_succ
File: Mathlib/Data/Nat/Set.lean

tactic: ext (_ | i) <;> simp [succ_pos, succ_ne_zero, Set.mem_setOf]
state_before: ⊢ range succ = {i | 0 < i}
Theorem: Subgroup.codisjoint_subgroupOf_sup
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [codisjoint_iff, sup_subgroupOf_eq, subgroupOf_self]
state_before: G : Type u_1
G' : Type ?u.612020
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.612029
inst✝¹ : AddGroup A
N : Type ?u.612035
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ Codisjoint (subgroupOf H (H ⊔ K)) (subgroupOf K (H ⊔ K))

tactic: exacts [le_sup_left, le_sup_right]
state_before: case hH
G : Type u_1
G' : Type ?u.612020
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.612029
inst✝¹ : AddGroup A
N : Type ?u.612035
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
G : Type u_1
G' : Type ?u.612020
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.612029
inst✝¹ : AddGroup A
N : Type ?u.612035
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
Theorem: Finset.update_piecewise_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [update_piecewise]
state_before: α : Type u_1
β : Type ?u.308183
γ : Type ?u.308186
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : DecidableEq α
i : α
hi : i ∈ s
v : δ i
⊢ update (piecewise s f g) i v = piecewise s (update f i v) g

tactic: refine' s.piecewise_congr (fun _ _ => rfl) fun j hj => update_noteq _ _ _
state_before: α : Type u_1
β : Type ?u.308183
γ : Type ?u.308186
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : DecidableEq α
i : α
hi : i ∈ s
v : δ i
⊢ piecewise s (update f i v) (update g i v) = piecewise s (update f i v) g

tactic: exact fun h => hj (h.symm ▸ hi)
state_before: α : Type u_1
β : Type ?u.308183
γ : Type ?u.308186
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : DecidableEq α
i : α
hi : i ∈ s
v : δ i
j : α
hj : ¬j ∈ s
⊢ j ≠ i
Theorem: Ordinal.lt_mul_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [not_ball, not_le, bex_def] using not_congr (@mul_le_of_limit b c a h)
state_before: α : Type ?u.211340
β : Type ?u.211343
γ : Type ?u.211346
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : IsLimit c
⊢ a < b * c ↔ ∃ c', c' < c ∧ a < b * c'
Theorem: Multiset.count_finset_sup
File: Mathlib/Data/Finset/Lattice.lean

tactic: letI := Classical.decEq α
state_before: F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s : Finset α
f : α → Multiset β
b : β
⊢ count b (Finset.sup s f) = Finset.sup s fun a => count b (f a)

tactic: refine' s.induction _ _
state_before: F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s : Finset α
f : α → Multiset β
b : β
this : DecidableEq α := Classical.decEq α
⊢ count b (Finset.sup s f) = Finset.sup s fun a => count b (f a)

tactic: exact count_zero _
state_before: case refine'_1
F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s : Finset α
f : α → Multiset β
b : β
this : DecidableEq α := Classical.decEq α
⊢ count b (Finset.sup ∅ f) = Finset.sup ∅ fun a => count b (f a)

tactic: intro i s _ ih
state_before: case refine'_2
F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s : Finset α
f : α → Multiset β
b : β
this : DecidableEq α := Classical.decEq α
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s →
      (count b (Finset.sup s f) = Finset.sup s fun a => count b (f a)) →
        count b (Finset.sup (insert a s) f) = Finset.sup (insert a s) fun a => count b (f a)

tactic: rw [Finset.sup_insert, sup_eq_union, count_union, Finset.sup_insert, ih]
state_before: case refine'_2
F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s✝ : Finset α
f : α → Multiset β
b : β
this : DecidableEq α := Classical.decEq α
i : α
s : Finset α
a✝ : ¬i ∈ s
ih : count b (Finset.sup s f) = Finset.sup s fun a => count b (f a)
⊢ count b (Finset.sup (insert i s) f) = Finset.sup (insert i s) fun a => count b (f a)

tactic: rfl
state_before: case refine'_2
F : Type ?u.410886
α : Type u_2
β : Type u_1
γ : Type ?u.410895
ι : Type ?u.410898
κ : Type ?u.410901
inst✝ : DecidableEq β
s✝ : Finset α
f : α → Multiset β
b : β
this : DecidableEq α := Classical.decEq α
i : α
s : Finset α
a✝ : ¬i ∈ s
ih : count b (Finset.sup s f) = Finset.sup s fun a => count b (f a)
⊢ max (count b (f i)) (Finset.sup s fun a => count b (f a)) = count b (f i) ⊔ Finset.sup s fun a => count b (f a)
Theorem: SemiconjBy.inv_symm_left_iff₀
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

tactic: simp only [ha, inv_zero, SemiconjBy.zero_left]
state_before: α : Type ?u.637
M₀ : Type ?u.640
G₀ : Type u_1
M₀' : Type ?u.646
G₀' : Type ?u.649
F : Type ?u.652
F' : Type ?u.655
inst✝ : GroupWithZero G₀
a x y x' y' : G₀
ha : a = 0
⊢ SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x
Theorem: Set.SurjOn.congr
File: Mathlib/Data/Set/Function.lean

tactic: rwa [SurjOn, ← H.image_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.40788
ι : Sort ?u.40791
π : α → Type ?u.40796
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h : SurjOn f₁ s t
H : EqOn f₁ f₂ s
⊢ SurjOn f₂ s t
Theorem: Real.Angle.abs_sin_eq_of_two_zsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: simp_rw [two_zsmul, ← two_nsmul] at h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ abs (sin θ) = abs (sin ψ)

tactic: exact abs_sin_eq_of_two_nsmul_eq h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ abs (sin θ) = abs (sin ψ)
Theorem: inv_mul_le_iff_le_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ b⁻¹ * a ≤ c ↔ a ≤ b * c
Theorem: Int.max_comm
File: Std/Data/Int/Lemmas.lean

tactic: simp only [Int.max_def]
state_before: a b : Int
⊢ max a b = max b a

tactic: by_cases h₁ : a ≤ b <;> by_cases h₂ : b ≤ a <;> simp [h₁, h₂]
state_before: a b : Int
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b

tactic: exact Int.le_antisymm h₂ h₁
state_before: case pos
a b : Int
h₁ : a ≤ b
h₂ : b ≤ a
⊢ b = a

tactic: cases not_or_intro h₁ h₂ <| Int.le_total ..
state_before: case neg
a b : Int
h₁ : ¬a ≤ b
h₂ : ¬b ≤ a
⊢ a = b
Theorem: EuclideanGeometry.angle_midpoint_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: simp [angle, hp1p2, -zero_lt_one]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
hp1p2 : p1 ≠ p2
⊢ ∠ p1 (midpoint ℝ p1 p2) p2 = π

tactic: rw [← neg_vsub_eq_vsub_rev p1 p2]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
hp1p2 : p1 ≠ p2
⊢ InnerProductGeometry.angle (p1 -ᵥ p2) (p2 -ᵥ p1) = π

tactic: apply angle_self_neg_of_nonzero
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
hp1p2 : p1 ≠ p2
⊢ InnerProductGeometry.angle (p1 -ᵥ p2) (-(p1 -ᵥ p2)) = π

tactic: simpa only [ne_eq, vsub_eq_zero_iff_eq]
state_before: case hx
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 : P
hp1p2 : p1 ≠ p2
⊢ p1 -ᵥ p2 ≠ 0
Theorem: Nat.factorizationEquiv_apply
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: cases n
state_before: n : ℕ+
⊢ ↑(↑factorizationEquiv n) = factorization ↑n

tactic: rfl
state_before: case mk
val✝ : ℕ
property✝ : 0 < val✝
⊢ ↑(↑factorizationEquiv { val := val✝, property := property✝ }) = factorization ↑{ val := val✝, property := property✝ }
Theorem: PFun.comp_id
File: Mathlib/Data/PFun.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.54011
δ : Type ?u.54014
ε : Type ?u.54017
ι : Type ?u.54020
f✝ f : α →. β
x✝¹ : α
x✝ : β
⊢ x✝ ∈ comp f (PFun.id α) x✝¹ ↔ x✝ ∈ f x✝¹
Theorem: comap_center_subst
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: subst h
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
H₁ H₂ : Subgroup G
inst✝¹ : Normal H₁
inst✝ : Normal H₂
h : H₁ = H₂
⊢ comap (mk' H₁) (center (G ⧸ H₁)) = comap (mk' H₂) (center (G ⧸ H₂))

tactic: rfl
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
H₁ : Subgroup G
inst✝¹ inst✝ : Normal H₁
⊢ comap (mk' H₁) (center (G ⧸ H₁)) = comap (mk' H₁) (center (G ⧸ H₁))