tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.sigmaComparison_map_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: ext j
state_before: β : Type w
C : Type u
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
G : C ⥤ D
f : β → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun b => G.obj (f b)
P : C
g : (j : β) → f j ⟶ P
⊢ sigmaComparison G f ≫ G.map (Sigma.desc g) = Sigma.desc fun j => G.map (g j)

tactic: simp only [Discrete.functor_obj, ι_comp_sigmaComparison_assoc, ← G.map_comp, colimit.ι_desc,
  Cofan.mk_pt, Cofan.mk_ι_app]
state_before: case h
β : Type w
C : Type u
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
G : C ⥤ D
f : β → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun b => G.obj (f b)
P : C
g : (j : β) → f j ⟶ P
j : β
⊢ Sigma.ι (fun b => G.obj (f b)) j ≫ sigmaComparison G f ≫ G.map (Sigma.desc g) =
    Sigma.ι (fun b => G.obj (f b)) j ≫ Sigma.desc fun j => G.map (g j)
Theorem: MeasureTheory.integrable_prod_iff
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: simp [Integrable, h1f, hasFiniteIntegral_prod_iff', h1f.norm.integral_prod_right',
  h1f.prod_mk_left]
state_before: α : Type u_1
α' : Type ?u.2396048
β : Type u_2
β' : Type ?u.2396054
γ : Type ?u.2396057
E : Type u_3
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
f : α × β → E
h1f : AEStronglyMeasurable f (Measure.prod μ ν)
⊢ Integrable f ↔ (∀ᵐ (x : α) ∂μ, Integrable fun y => f (x, y)) ∧ Integrable fun x => ∫ (y : β), ‖f (x, y)‖ ∂ν
Theorem: List.mapM'_eq_mapM
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [go, mapM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
l : List α
⊢ mapM' f l = mapM f l

tactic: simp
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
l : List α
acc : List β
⊢ mapM.loop f [] acc = do
    let __do_lift ← mapM' f []
    pure (reverse acc ++ __do_lift)

tactic: simp [go l]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
l✝ : List α
a : α
l : List α
acc : List β
⊢ mapM.loop f (a :: l) acc = do
    let __do_lift ← mapM' f (a :: l)
    pure (reverse acc ++ __do_lift)
Theorem: Set.preimage_eq_preimage'
File: Mathlib/Data/Set/Image.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' t ↔ s = t

tactic: rintro rfl
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ s = t → f ⁻¹' s = f ⁻¹' t

tactic: rfl
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t s : Set α
f : β → α
hs ht : s ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' s

tactic: intro h
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
⊢ f ⁻¹' s = f ⁻¹' t → s = t

tactic: apply Subset.antisymm
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
h : f ⁻¹' s = f ⁻¹' t
⊢ s = t

tactic: rw [← preimage_subset_preimage_iff hs, h]
state_before: case mp.h₁
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
h : f ⁻¹' s = f ⁻¹' t
⊢ s ⊆ t

tactic: rw [← preimage_subset_preimage_iff ht, h]
state_before: case mp.h₂
α : Type u_1
β : Type u_2
γ : Type ?u.77374
ι : Sort ?u.77377
ι' : Sort ?u.77380
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
ht : t ⊆ range f
h : f ⁻¹' s = f ⁻¹' t
⊢ t ⊆ s
Theorem: SimpleGraph.exists_minimal_degree_vertex
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: obtain ⟨t, ht : _ = _⟩ := min_of_nonempty (univ_nonempty.image fun v => G.degree v)
state_before: ι : Sort ?u.289282
𝕜 : Type ?u.289285
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
⊢ ∃ v, minDegree G = degree G v

tactic: obtain ⟨v, _, rfl⟩ := mem_image.mp (mem_of_min ht)
state_before: case intro
ι : Sort ?u.289282
𝕜 : Type ?u.289285
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
t : ℕ
ht : Finset.min (image (fun v => degree G v) univ) = ↑t
⊢ ∃ v, minDegree G = degree G v

tactic: refine' ⟨v, by simp [minDegree, ht]⟩
state_before: case intro.intro.intro
ι : Sort ?u.289282
𝕜 : Type ?u.289285
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
left✝ : v ∈ univ
ht : Finset.min (image (fun v => degree G v) univ) = ↑(degree G v)
⊢ ∃ v, minDegree G = degree G v

tactic: simp [minDegree, ht]
state_before: ι : Sort ?u.289282
𝕜 : Type ?u.289285
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
left✝ : v ∈ univ
ht : Finset.min (image (fun v => degree G v) univ) = ↑(degree G v)
⊢ minDegree G = degree G v
Theorem: Multiset.add_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.11263
δ : Type ?u.11266
a : α
s t : Multiset α
f g : α → Multiset β
⊢ bind (s + t) f = bind s f + bind t f
Theorem: RatFunc.eval_one
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp [eval]
state_before: K : Type u
inst✝¹ : Field K
L : Type u_1
inst✝ : Field L
f : K →+* L
a : L
⊢ eval f a 1 = 1
Theorem: IsCompact.div_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, mul_comm, hs.mul_closedBall hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ s / closedBall x δ = x⁻¹ • cthickening δ s
Theorem: Equiv.pointReflection_fixed_iff_of_injective_bit0
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [pointReflection_apply, eq_comm, eq_vadd_iff_vsub_eq, ← neg_vsub_eq_vsub_rev,
  neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero, h.eq_iff, vsub_eq_zero_iff_eq, eq_comm]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
x y : P
h : Injective bit0
⊢ ↑(pointReflection x) y = y ↔ y = x
Theorem: ModuleCat.MonoidalCategory.pentagon
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

tactic: convert pentagon_aux R W X Y Z using 1
state_before: R : Type u
inst✝ : CommRing R
W : ModuleCat R
X : ModuleCat R
Y : ModuleCat R
Z : ModuleCat R
⊢ tensorHom (associator W X Y).hom (𝟙 Z) ≫
      (associator W (tensorObj X Y) Z).hom ≫ tensorHom (𝟙 W) (associator X Y Z).hom =
    (associator (tensorObj W X) Y Z).hom ≫ (associator W X (tensorObj Y Z)).hom
Theorem: norm_add_lt_of_not_sameRay
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: simp only [sameRay_iff_inv_norm_smul_eq, not_or, ← Ne.def] at h
state_before: 𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ x y
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: rcases h with ⟨hx, hy, hne⟩
state_before: 𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : x ≠ 0 ∧ y ≠ 0 ∧ ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: rw [← norm_pos_iff] at hx hy
state_before: case intro.intro
𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : x ≠ 0
hy : y ≠ 0
hne : ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: have hxy : 0 < ‖x‖ + ‖y‖ := add_pos hx hy
state_before: case intro.intro
𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : 0 < ‖x‖
hy : 0 < ‖y‖
hne : ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: have :=
  combo_mem_ball_of_ne (inv_norm_smul_mem_closed_unit_ball x)
    (inv_norm_smul_mem_closed_unit_ball y) hne (div_pos hx hxy) (div_pos hy hxy)
    (by rw [← add_div, div_self hxy.ne'])
state_before: case intro.intro
𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : 0 < ‖x‖
hy : 0 < ‖y‖
hne : ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
hxy : 0 < ‖x‖ + ‖y‖
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: rwa [mem_ball_zero_iff, div_eq_inv_mul, div_eq_inv_mul, mul_smul, mul_smul, smul_inv_smul₀ hx.ne',
  smul_inv_smul₀ hy.ne', ← smul_add, norm_smul, Real.norm_of_nonneg (inv_pos.2 hxy).le, ←
  div_eq_inv_mul, div_lt_one hxy] at this
state_before: case intro.intro
𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : 0 < ‖x‖
hy : 0 < ‖y‖
hne : ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
hxy : 0 < ‖x‖ + ‖y‖
this : (‖x‖ / (‖x‖ + ‖y‖)) • ‖x‖⁻¹ • x + (‖y‖ / (‖x‖ + ‖y‖)) • ‖y‖⁻¹ • y ∈ ball 0 1
⊢ ‖x + y‖ < ‖x‖ + ‖y‖

tactic: rw [← add_div, div_self hxy.ne']
state_before: 𝕜 : Type ?u.54272
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : 0 < ‖x‖
hy : 0 < ‖y‖
hne : ‖x‖⁻¹ • x ≠ ‖y‖⁻¹ • y
hxy : 0 < ‖x‖ + ‖y‖
⊢ ‖x‖ / (‖x‖ + ‖y‖) + ‖y‖ / (‖x‖ + ‖y‖) = 1
Theorem: CircleDeg1Lift.commute_sub_int
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [sub_eq_add_neg] using
  (f.commute_add_int n).inverses_right (Equiv.addRight _).right_inv (Equiv.addRight _).left_inv
state_before: f g : CircleDeg1Lift
n : ℤ
⊢ Function.Commute ↑f fun x => x - ↑n
Theorem: Finset.image_congr
File: Mathlib/Data/Finset/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68613
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
h : Set.EqOn f g ↑s
⊢ image f s = image g s

tactic: simp_rw [mem_image, ← bex_def]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.68613
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
h : Set.EqOn f g ↑s
a✝ : β
⊢ a✝ ∈ image f s ↔ a✝ ∈ image g s

tactic: exact bex_congr fun x hx => by rw [h hx]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.68613
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
h : Set.EqOn f g ↑s
a✝ : β
⊢ (∃ x x_1, f x = a✝) ↔ ∃ x x_1, g x = a✝

tactic: rw [h hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68613
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
h : Set.EqOn f g ↑s
a✝ : β
x : α
hx : x ∈ s
⊢ f x = a✝ ↔ g x = a✝
Theorem: Set.exists_subset_range_iff
File: Mathlib/Data/Set/Image.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.75384
ι : Sort ?u.75387
ι' : Sort ?u.75390
f✝ : ι → α
s t : Set α
f : α → β
p : Set β → Prop
⊢ (∃ s x, p s) ↔ ∃ s, p (f '' s)
Theorem: ENNReal.ofReal_inv_of_pos
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.ofReal, ENNReal.ofReal, ← @coe_inv (Real.toNNReal x) (by simp [hx]), coe_eq_coe,
  ← Real.toNNReal_inv]
state_before: α : Type ?u.816393
β : Type ?u.816396
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ
hx : 0 < x
⊢ (ENNReal.ofReal x)⁻¹ = ENNReal.ofReal x⁻¹

tactic: simp [hx]
state_before: α : Type ?u.816393
β : Type ?u.816396
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ
hx : 0 < x
⊢ Real.toNNReal x ≠ 0
Theorem: IsLocalization.mk'_add_eq_iff_add_mul_eq_mul
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [← mk'_spec S x y, ← IsUnit.mul_left_inj (IsLocalization.map_units S y), right_distrib]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.576510
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
z₁ z₂ : S
⊢ mk' S x y + z₁ = z₂ ↔ ↑(algebraMap R S) x + z₁ * ↑(algebraMap R S) ↑y = z₂ * ↑(algebraMap R S) ↑y
Theorem: Action.leftDual_ρ
File: Mathlib/RepresentationTheory/Action.lean

tactic: rw [← SingleObj.inv_as_inv]
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ ↑(ᘁX).ρ h = ᘁ↑X.ρ h⁻¹

tactic: rfl
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ ↑(ᘁX).ρ h = ᘁ↑X.ρ (inv h)

case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1

case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : GroupCat
X : Action V ((forget₂ GroupCat MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1
Theorem: EReal.range_coe_eq_Ioo
File: Mathlib/Data/Real/EReal.lean

tactic: ext x
state_before: ⊢ range Real.toEReal = Ioo ⊥ ⊤

tactic: induction x using EReal.rec <;> simp
state_before: case h
x : EReal
⊢ x ∈ range Real.toEReal ↔ x ∈ Ioo ⊥ ⊤
Theorem: div_sq_cancel
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: by_cases ha : a = 0
state_before: G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
⊢ a ^ 2 * b / a = a * b

tactic: rw [sq, mul_assoc, mul_div_cancel_left _ ha]
state_before: case neg
G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
ha : ¬a = 0
⊢ a ^ 2 * b / a = a * b

tactic: simp [ha]
state_before: case pos
G₀ : Type u_1
inst✝ : CommGroupWithZero G₀
a b : G₀
ha : a = 0
⊢ a ^ 2 * b / a = a * b
Theorem: mul_eq_one_iff_inv_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [mul_eq_one_iff_eq_inv, inv_eq_iff_eq_inv]
state_before: α : Type ?u.53359
β : Type ?u.53362
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a * b = 1 ↔ a⁻¹ = b
Theorem: isOpen_singleton_iff_nhds_eq_pure
File: Mathlib/Topology/Basic.lean

tactic: constructor
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
⊢ IsOpen {a} ↔ 𝓝 a = pure a

tactic: intro h
state_before: case mp
α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
⊢ IsOpen {a} → 𝓝 a = pure a

tactic: apply le_antisymm _ (pure_le_nhds a)
state_before: case mp
α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
h : IsOpen {a}
⊢ 𝓝 a = pure a

tactic: rw [le_pure_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
h : IsOpen {a}
⊢ 𝓝 a ≤ pure a

tactic: exact h.mem_nhds (mem_singleton a)
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
h : IsOpen {a}
⊢ {a} ∈ 𝓝 a

tactic: intro h
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
⊢ 𝓝 a = pure a → IsOpen {a}

tactic: simp [isOpen_iff_nhds, h]
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
h : 𝓝 a = pure a
⊢ IsOpen {a}
Theorem: Finset.sum_mul_boole
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
b : β
f✝ g : α → β
inst✝¹ : NonAssocSemiring β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
⊢ (∑ x in s, f x * if a = x then 1 else 0) = if a ∈ s then f a else 0
Theorem: List.stronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: induction' l with f l ihl
state_before: α : Type u_1
β : Type ?u.109795
γ : Type ?u.109798
ι : Type ?u.109801
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : List (α → M)
hl : ∀ (f : α → M), f ∈ l → StronglyMeasurable f
⊢ StronglyMeasurable (List.prod l)

tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
α : Type u_1
β : Type ?u.109795
γ : Type ?u.109798
ι : Type ?u.109801
inst✝³ : Countable ι
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → StronglyMeasurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → StronglyMeasurable f) → StronglyMeasurable (List.prod l)
hl : ∀ (f_1 : α → M), f_1 ∈ f :: l → StronglyMeasurable f_1
⊢ StronglyMeasurable (List.prod (f :: l))

tactic: rw [List.prod_cons]
state_before: case cons
α : Type u_1
β : Type ?u.109795
γ : Type ?u.109798
ι : Type ?u.109801
inst✝³ : Countable ι
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → StronglyMeasurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → StronglyMeasurable f) → StronglyMeasurable (List.prod l)
hl : StronglyMeasurable f ∧ ∀ (x : α → M), x ∈ l → StronglyMeasurable x
⊢ StronglyMeasurable (List.prod (f :: l))

tactic: exact hl.1.mul (ihl hl.2)
state_before: case cons
α : Type u_1
β : Type ?u.109795
γ : Type ?u.109798
ι : Type ?u.109801
inst✝³ : Countable ι
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → StronglyMeasurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → StronglyMeasurable f) → StronglyMeasurable (List.prod l)
hl : StronglyMeasurable f ∧ ∀ (x : α → M), x ∈ l → StronglyMeasurable x
⊢ StronglyMeasurable (f * List.prod l)

tactic: exact stronglyMeasurable_one
state_before: case nil
α : Type u_1
β : Type ?u.109795
γ : Type ?u.109798
ι : Type ?u.109801
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l → StronglyMeasurable f
hl : ∀ (f : α → M), f ∈ [] → StronglyMeasurable f
⊢ StronglyMeasurable (List.prod [])
Theorem: Rel.mem_interedges_iff
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [interedges, mem_filter, Finset.mem_product, and_assoc]
state_before: 𝕜 : Type ?u.1103
ι : Type ?u.1106
κ : Type ?u.1109
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
x : α × β
⊢ x ∈ interedges r s t ↔ x.fst ∈ s ∧ x.snd ∈ t ∧ r x.fst x.snd
Theorem: Int.emod_two_eq_zero_or_one
File: Mathlib/Data/Int/Order/Basic.lean

tactic: decide
state_before: a b : ℤ
n✝ : ℕ
n : ℤ
⊢ 0 ≤ 2

tactic: decide
state_before: a b : ℤ
n✝ : ℕ
n : ℤ
⊢ abs 2 ≠ 0

tactic: decide
state_before: a b : ℤ
n✝ : ℕ
n : ℤ
h : n % 2 < 2
⊢ 2 ≠ 0

tactic: rw [Nat.cast_add]
state_before: a b : ℤ
n✝ : ℕ
n : ℤ
h : n % 2 < 2
h₁✝ : 0 ≤ n % 2
k : ℕ
h₁ : ↑(k + 2) < 2
x✝ : 0 ≤ ↑(k + 2)
⊢ 2 ≤ ↑(k + 2)

tactic: exact (le_add_iff_nonneg_left 2).2 (NonNeg.mk k)
state_before: a b : ℤ
n✝ : ℕ
n : ℤ
h : n % 2 < 2
h₁✝ : 0 ≤ n % 2
k : ℕ
h₁ : ↑(k + 2) < 2
x✝ : 0 ≤ ↑(k + 2)
⊢ 2 ≤ ↑k + ↑2

tactic: cases h₁
state_before: a✝ b : ℤ
n✝ : ℕ
n : ℤ
h : n % 2 < 2
h₁✝ : 0 ≤ n % 2
a : ℕ
x✝ : -[a+1] < 2
h₁ : 0 ≤ -[a+1]
⊢ -[a+1] = 0 ∨ -[a+1] = 1
Theorem: continuous_circleMap_inv
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: have : ∀ θ, circleMap z R θ - w ≠ 0 := by
  simp_rw [sub_ne_zero]
  exact fun θ => circleMap_ne_mem_ball hw θ
state_before: E : Type ?u.59862
inst✝ : NormedAddCommGroup E
R : ℝ
z w : ℂ
hw : w ∈ ball z R
⊢ Continuous fun θ => (circleMap z R θ - w)⁻¹

tactic: exact Continuous.inv₀ (by continuity) this
state_before: E : Type ?u.59862
inst✝ : NormedAddCommGroup E
R : ℝ
z w : ℂ
hw : w ∈ ball z R
this : ∀ (θ : ℝ), circleMap z R θ - w ≠ 0
⊢ Continuous fun θ => (circleMap z R θ - w)⁻¹

tactic: simp_rw [sub_ne_zero]
state_before: E : Type ?u.59862
inst✝ : NormedAddCommGroup E
R : ℝ
z w : ℂ
hw : w ∈ ball z R
⊢ ∀ (θ : ℝ), circleMap z R θ - w ≠ 0

tactic: exact fun θ => circleMap_ne_mem_ball hw θ
state_before: E : Type ?u.59862
inst✝ : NormedAddCommGroup E
R : ℝ
z w : ℂ
hw : w ∈ ball z R
⊢ ∀ (θ : ℝ), circleMap z R θ ≠ w

tactic: continuity
state_before: E : Type ?u.59862
inst✝ : NormedAddCommGroup E
R : ℝ
z w : ℂ
hw : w ∈ ball z R
this : ∀ (θ : ℝ), circleMap z R θ - w ≠ 0
⊢ Continuous fun θ => circleMap z R θ - w
Theorem: UnionFind.lt_rankMax
File: Mathlib/Data/UnionFind.lean

tactic: simp [rank]
state_before: α : Type u_1
self : UnionFind α
i : ℕ
⊢ rank self i < rankMax self

tactic: split
state_before: α : Type u_1
self : UnionFind α
i : ℕ
⊢ (if h : i < size self then self.arr[i].rank else 0) < rankMax self

tactic: {apply lt_rankMax'}
state_before: case inl
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : i < size self
⊢ self.arr[i].rank < rankMax self

case inr
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < size self
⊢ 0 < rankMax self

tactic: apply Nat.succ_pos
state_before: case inr
α : Type u_1
self : UnionFind α
i : ℕ
h✝ : ¬i < size self
⊢ 0 < rankMax self
Theorem: Real.le_logb_iff_rpow_le
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_le_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hy]
state_before: b x y : ℝ
hb : 1 < b
hy : 0 < y
⊢ x ≤ logb b y ↔ b ^ x ≤ y
Theorem: Wbtw.rotate_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [← wbtw_rotate_iff R x, and_iff_right h]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.222353
P : Type u_3
P' : Type ?u.222359
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
h : Wbtw R x y z
⊢ Wbtw R z x y ↔ x = y
Theorem: Nat.totient_pos
File: Mathlib/Data/Nat/Totient.lean

tactic: decide
state_before: ⊢ 0 < 0 → 0 < φ 0

tactic: simp [totient]
state_before: ⊢ 0 < 1 → 0 < φ 1

tactic: simp
state_before: n : ℕ
x✝ : 0 < n + 2
⊢ 1 < n + 2
Theorem: collinear_insert_insert_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_insert_iff_of_mem_affineSpan
    ((AffineSubspace.le_def' _ _).1 (affineSpan_mono k (Set.subset_insert _ _)) _ h₁),
  collinear_insert_iff_of_mem_affineSpan h₂]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.323622
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ : P
h₁ : p₁ ∈ affineSpan k {p₃, p₄}
h₂ : p₂ ∈ affineSpan k {p₃, p₄}
⊢ Collinear k {p₁, p₂, p₃, p₄}

tactic: exact collinear_pair _ _ _
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.323622
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ : P
h₁ : p₁ ∈ affineSpan k {p₃, p₄}
h₂ : p₂ ∈ affineSpan k {p₃, p₄}
⊢ Collinear k {p₃, p₄}
Theorem: Real.Angle.sign_coe_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sin_coe, neg_div, Real.sin_neg, sin_pi_div_two, Left.sign_neg, sign_one]
state_before: ⊢ sign ↑(-π / 2) = -1