tasksource/leandojo huggingface dataset:
Theorem: lowerCentralSeries_map_subtype_le
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: induction' n with d hd
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
n : ℕ
⊢ Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } n) ≤ lowerCentralSeries G n

tactic: simp
state_before: case zero
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
⊢ Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } Nat.zero) ≤ lowerCentralSeries G Nat.zero

tactic: rw [lowerCentralSeries_succ, lowerCentralSeries_succ, MonoidHom.map_closure]
state_before: case succ
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
d : ℕ
hd : Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } d) ≤ lowerCentralSeries G d
⊢ Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } (Nat.succ d)) ≤ lowerCentralSeries G (Nat.succ d)

tactic: apply Subgroup.closure_mono
state_before: case succ
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
d : ℕ
hd : Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } d) ≤ lowerCentralSeries G d
⊢ closure
      (↑(Subgroup.subtype H) ''
        {x | ∃ p, p ∈ lowerCentralSeries { x // x ∈ H } d ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x}) ≤
    closure {x | ∃ p, p ∈ lowerCentralSeries G d ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x}

tactic: rintro x1 ⟨x2, ⟨x3, hx3, x4, _hx4, rfl⟩, rfl⟩
state_before: case succ.h'
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
d : ℕ
hd : Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } d) ≤ lowerCentralSeries G d
⊢ ↑(Subgroup.subtype H) '' {x | ∃ p, p ∈ lowerCentralSeries { x // x ∈ H } d ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x} ⊆
    {x | ∃ p, p ∈ lowerCentralSeries G d ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x}

tactic: exact ⟨x3, hd (mem_map.mpr ⟨x3, hx3, rfl⟩), x4, by simp⟩
state_before: case succ.h'.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
d : ℕ
hd : Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } d) ≤ lowerCentralSeries G d
x3 : { x // x ∈ H }
hx3 : x3 ∈ lowerCentralSeries { x // x ∈ H } d
x4 : { x // x ∈ H }
_hx4 : x4 ∈ ⊤
⊢ ↑(Subgroup.subtype H) (x3 * x4 * x3⁻¹ * x4⁻¹) ∈
    {x | ∃ p, p ∈ lowerCentralSeries G d ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x}

tactic: simp
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
d : ℕ
hd : Subgroup.map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } d) ≤ lowerCentralSeries G d
x3 : { x // x ∈ H }
hx3 : x3 ∈ lowerCentralSeries { x // x ∈ H } d
x4 : { x // x ∈ H }
_hx4 : x4 ∈ ⊤
⊢ ↑x4 ∈ ⊤ ∧ ↑x3 * ↑x4 * (↑x3)⁻¹ * (↑x4)⁻¹ = ↑(Subgroup.subtype H) (x3 * x4 * x3⁻¹ * x4⁻¹)
Theorem: nhds_eq_comap_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext s
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58422
inst✝ : UniformSpace α
x : α
⊢ 𝓝 x = comap (Prod.mk x) (𝓤 α)

tactic: rw [mem_nhds_uniformity_iff_right, mem_comap_prod_mk]
state_before: case a
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58422
inst✝ : UniformSpace α
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ comap (Prod.mk x) (𝓤 α)
Theorem: Pmf.mem_support_ofMultiset_iff
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.182816
γ : Type ?u.182819
s : Multiset α
hs : s ≠ 0
a : α
⊢ a ∈ support (ofMultiset s hs) ↔ a ∈ Multiset.toFinset s
Theorem: Order.Ico_pred_right_eq_insert
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ioi_inter_Iic, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iic.2 h)]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
h : a ≤ b
⊢ Ioc (pred a) b = insert a (Ioc a b)
Theorem: Complex.circleIntegral_div_sub_of_differentiable_on_off_countable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: simpa only [smul_eq_mul, div_eq_inv_mul] using
  circleIntegral_sub_inv_smul_of_differentiable_on_off_countable hs hw hc hd
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
s : Set ℂ
hs : Set.Countable s
hw : w ∈ ball c R
f : ℂ → ℂ
hc : ContinuousOn f (closedBall c R)
hd : ∀ (z : ℂ), z ∈ ball c R \ s → DifferentiableAt ℂ f z
⊢ (∮ (z : ℂ) in C(c, R), f z / (z - w)) = 2 * ↑π * I * f w
Theorem: Submonoid.top_prod
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp [mem_prod, MonoidHom.coe_snd]
state_before: M : Type u_2
N : Type u_1
P : Type ?u.99119
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.99140
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid N
x : M × N
⊢ x ∈ prod ⊤ s ↔ x ∈ comap (MonoidHom.snd M N) s
Theorem: GeneralizedContinuedFraction.first_denominator_eq
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [denom_eq_conts_b, first_continuant_eq zeroth_s_eq]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : Stream'.Seq.get? g.s 0 = some gp
⊢ denominators g 1 = gp.b
Theorem: posMulMono_iff_mulPosMono
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simp only [PosMulMono, MulPosMono, mul_comm]
state_before: α : Type u_1
a b c d : α
inst✝² : CommSemigroup α
inst✝¹ : Zero α
inst✝ : Preorder α
⊢ PosMulMono α ↔ MulPosMono α
Theorem: PadicInt.ker_toZMod
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: ext x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ RingHom.ker toZMod = maximalIdeal ℤ_[p]

tactic: rw [RingHom.mem_ker]
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ RingHom.ker toZMod ↔ x ∈ maximalIdeal ℤ_[p]

tactic: constructor
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ↑toZMod x = 0 ↔ x ∈ maximalIdeal ℤ_[p]

tactic: intro h
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ↑toZMod x = 0 → x ∈ maximalIdeal ℤ_[p]

tactic: simpa only [h, ZMod.cast_zero, sub_zero] using toZMod_spec x
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : ↑toZMod x = 0
⊢ x ∈ maximalIdeal ℤ_[p]

tactic: intro h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ maximalIdeal ℤ_[p] → ↑toZMod x = 0

tactic: rw [← sub_zero x] at h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x ∈ maximalIdeal ℤ_[p]
⊢ ↑toZMod x = 0

tactic: dsimp [toZMod, toZModHom]
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ ↑toZMod x = 0

tactic: convert zmod_congr_of_sub_mem_max_ideal x _ 0 _ h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ ↑(zmodRepr x) = 0

tactic: norm_cast
state_before: case h.e'_3
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ 0 = ↑0

case h.mpr.convert_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ x - ↑(zmodRepr x) ∈ maximalIdeal ℤ_[p]

tactic: apply sub_zmodRepr_mem
state_before: case h.mpr.convert_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ x - ↑(zmodRepr x) ∈ maximalIdeal ℤ_[p]
Theorem: Matrix.IsHermitian.transpose
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [IsHermitian, conjTranspose, transpose_map]
state_before: α : Type u_2
β : Type ?u.3659
m : Type ?u.3662
n : Type u_1
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : IsHermitian A
⊢ IsHermitian Aᵀ

tactic: exact congr_arg Matrix.transpose h
state_before: α : Type u_2
β : Type ?u.3659
m : Type ?u.3662
n : Type u_1
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
h : IsHermitian A
⊢ (Matrix.map Aᵀ star)ᵀ = Aᵀ
Theorem: Finset.mk_mem_sigmaLift
File: Mathlib/Data/Finset/Sigma.lean

tactic: rw [sigmaLift, dif_pos rfl, mem_map]
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
i : ι
a : α i
b : β i
x : γ i
⊢ { fst := i, snd := x } ∈ sigmaLift f { fst := i, snd := a } { fst := i, snd := b } ↔ x ∈ f a b

tactic: refine' ⟨_, fun hx => ⟨_, hx, rfl⟩⟩
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
i : ι
a : α i
b : β i
x : γ i
⊢ (∃ a_1,
      a_1 ∈
          f ((_ : { fst := i, snd := a }.fst = { fst := i, snd := a }.fst) ▸ { fst := i, snd := a }.snd)
            { fst := i, snd := b }.snd ∧
        ↑(Embedding.sigmaMk { fst := i, snd := b }.fst) a_1 = { fst := i, snd := x }) ↔
    x ∈ f a b

tactic: rintro ⟨x, hx, _, rfl⟩
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
i : ι
a : α i
b : β i
x : γ i
⊢ (∃ a_1,
      a_1 ∈
          f ((_ : { fst := i, snd := a }.fst = { fst := i, snd := a }.fst) ▸ { fst := i, snd := a }.snd)
            { fst := i, snd := b }.snd ∧
        ↑(Embedding.sigmaMk { fst := i, snd := b }.fst) a_1 = { fst := i, snd := x }) →
    x ∈ f a b

tactic: exact hx
state_before: case intro.intro.refl
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
i : ι
a : α i
b : β i
x : γ i
hx :
  x ∈
    f ((_ : { fst := i, snd := a }.fst = { fst := i, snd := a }.fst) ▸ { fst := i, snd := a }.snd)
      { fst := i, snd := b }.snd
⊢ x ∈ f a b
Theorem: NormedAddGroupHom.opNorm_neg
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: simp only [norm_def, coe_neg, norm_neg, Pi.neg_apply]
state_before: V : Type ?u.324499
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.324508
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g f : NormedAddGroupHom V₁ V₂
⊢ ‖-f‖ = ‖f‖
Theorem: Pell.pell_eq
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: repeat' rw [Int.ofNat_mul]; exact pn
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1

tactic: rw [Int.ofNat_mul]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1

tactic: exact pn
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n) * ↑(xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1

tactic: rw [Int.ofNat_sub hl]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n - Pell.d a1 * yn a1 n * yn a1 n) = ↑1

tactic: exact h
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = ↑1
Theorem: inner_eq_norm_mul_iff
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rcases eq_or_ne x 0 with (rfl | h₀)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3212961
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x y = ↑‖x‖ * ↑‖y‖ ↔ ↑‖y‖ • x = ↑‖x‖ • y

tactic: simp
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3212961
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
y : E
⊢ inner 0 y = ↑‖0‖ * ↑‖y‖ ↔ ↑‖y‖ • 0 = ↑‖0‖ • y

tactic: rw [inner_eq_norm_mul_iff_div h₀, div_eq_inv_mul, mul_smul, inv_smul_eq_iff₀]
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3212961
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
h₀ : x ≠ 0
⊢ inner x y = ↑‖x‖ * ↑‖y‖ ↔ ↑‖y‖ • x = ↑‖x‖ • y

tactic: rwa [Ne.def, ofReal_eq_zero, norm_eq_zero]
state_before: case inr.ha
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3212961
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
h₀ : x ≠ 0
⊢ ↑‖x‖ ≠ 0
Theorem: Nat.prime_mul_iff
File: Mathlib/Data/Nat/Prime.lean

tactic: simp only [iff_self_iff, irreducible_mul_iff, ← irreducible_iff_nat_prime, Nat.isUnit_iff]
state_before: a b : ℕ
⊢ Prime (a * b) ↔ Prime a ∧ b = 1 ∨ Prime b ∧ a = 1
Theorem: SimplicialObject.Splitting.PInfty_comp_πSummand_id
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: conv_rhs => rw [← id_comp (s.πSummand _)]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
n : ℕ
⊢ HomologicalComplex.Hom.f PInfty n ≫ πSummand s (IndexSet.id [n].op) = πSummand s (IndexSet.id [n].op)

tactic: symm
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
n : ℕ
⊢ HomologicalComplex.Hom.f PInfty n ≫ πSummand s (IndexSet.id [n].op) =
    𝟙 (X.obj [n].op) ≫ πSummand s (IndexSet.id [n].op)

tactic: rw [← sub_eq_zero, ← sub_comp, ← comp_PInfty_eq_zero_iff, sub_comp, id_comp, PInfty_f_idem,
  sub_self]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
n : ℕ
⊢ 𝟙 (X.obj [n].op) ≫ πSummand s (IndexSet.id [n].op) =
    HomologicalComplex.Hom.f PInfty n ≫ πSummand s (IndexSet.id [n].op)
Theorem: CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : MonoidalCategory C
W X Y Z : C
⊢ (α_ W (X ⊗ Y) Z).inv ≫ ((α_ W X Y).inv ⊗ 𝟙 Z) ≫ (α_ (W ⊗ X) Y Z).hom = (𝟙 W ⊗ (α_ X Y Z).hom) ≫ (α_ W X (Y ⊗ Z)).inv
Theorem: MulChar.map_ringChar
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: rw [ringChar.Nat.cast_ringChar, χ.map_zero]
state_before: R✝ : Type u
inst✝³ : CommMonoid R✝
R' : Type v
inst✝² : CommMonoidWithZero R'
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
χ : MulChar R R'
⊢ ↑χ ↑(ringChar R) = 0
Theorem: interior_union_isClosed_of_interior_empty
File: Mathlib/Topology/Basic.lean

tactic: rwa [(IsOpen.sdiff hu₁ h₁).subset_interior_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s t : Set α
h₁ : IsClosed s
h₂ : interior t = ∅
x : α
x✝ : x ∈ interior (s ∪ t)
u : Set α
hu₁ : IsOpen u
hu₂ : u ⊆ s ∪ t
hx₁ : x ∈ u
hx₂ : ¬x ∈ s
this : u \ s ⊆ t
⊢ u \ s ⊆ interior t

tactic: rwa [h₂] at this
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s t : Set α
h₁ : IsClosed s
h₂ : interior t = ∅
x : α
x✝ : x ∈ interior (s ∪ t)
u : Set α
hu₁ : IsOpen u
hu₂ : u ⊆ s ∪ t
hx₁ : x ∈ u
hx₂ : ¬x ∈ s
this✝ : u \ s ⊆ t
this : u \ s ⊆ interior t
⊢ u \ s ⊆ ∅
Theorem: Cardinal.one_toNat
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← toNat_cast 1, Nat.cast_one]
state_before: α β : Type u
⊢ ↑toNat 1 = 1
Theorem: AddMonoid.isTorsion_iff_isTorsion_nat
File: Mathlib/Algebra/Module/Torsion.lean

tactic: refine' ⟨fun h x => _, fun h x => _⟩
state_before: R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
⊢ IsTorsion M ↔ Module.IsTorsion ℕ M

tactic: obtain ⟨n, h0, hn⟩ := (isOfFinAddOrder_iff_nsmul_eq_zero x).mp (h x)
state_before: case refine'_1
R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
h : IsTorsion M
x : M
⊢ ∃ a, a • x = 0

tactic: exact ⟨⟨n, mem_nonZeroDivisors_of_ne_zero <| ne_of_gt h0⟩, hn⟩
state_before: case refine'_1.intro.intro
R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
h : IsTorsion M
x : M
n : ℕ
h0 : 0 < n
hn : n • x = 0
⊢ ∃ a, a • x = 0

tactic: rw [isOfFinAddOrder_iff_nsmul_eq_zero]
state_before: case refine'_2
R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
h : Module.IsTorsion ℕ M
x : M
⊢ IsOfFinAddOrder x

tactic: obtain ⟨n, hn⟩ := @h x
state_before: case refine'_2
R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
h : Module.IsTorsion ℕ M
x : M
⊢ ∃ n, 0 < n ∧ n • x = 0

tactic: refine' ⟨n, Nat.pos_of_ne_zero (nonZeroDivisors.coe_ne_zero _), hn⟩
state_before: case refine'_2.intro
R : Type ?u.754879
M : Type u_1
inst✝ : AddCommMonoid M
h : Module.IsTorsion ℕ M
x : M
n : { x // x ∈ ℕ⁰ }
hn : n • x = 0
⊢ ∃ n, 0 < n ∧ n • x = 0
Theorem: Set.mem_iInter₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [mem_iInter]
state_before: α : Type ?u.42954
β : Type ?u.42957
γ : Type u_1
ι : Sort u_2
ι' : Sort ?u.42966
ι₂ : Sort ?u.42969
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.42979
κ₂ : ι → Sort ?u.42984
κ' : ι' → Sort ?u.42989
x : γ
s : (i : ι) → κ i → Set γ
⊢ (x ∈ ⋂ (i : ι) (j : κ i), s i j) ↔ ∀ (i : ι) (j : κ i), x ∈ s i j
Theorem: convex_iff_ordConnected
File: Mathlib/Analysis/Convex/Basic.lean

tactic: simp_rw [convex_iff_segment_subset, segment_eq_uIcc, ordConnected_iff_uIcc_subset]
state_before: 𝕜 : Type u_1
E : Type ?u.282167
F : Type ?u.282170
β : Type ?u.282173
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
⊢ Convex 𝕜 s ↔ OrdConnected s
Theorem: primorial_add_dvd
File: Mathlib/NumberTheory/Primorial.lean

tactic: rw [mem_filter, mem_Ico] at hp
state_before: m n : ℕ
h : n ≤ m
p : ℕ
hp : p ∈ filter Nat.Prime (Ico (m + 1) (m + n + 1))
⊢ p ∣ Nat.choose (m + n) m

tactic: exact hp.2.dvd_choose_add hp.1.1 (h.trans_lt (m.lt_succ_self.trans_le hp.1.1))
    (Nat.lt_succ_iff.1 hp.1.2)
state_before: m n : ℕ
h : n ≤ m
p : ℕ
hp : (m + 1 ≤ p ∧ p < m + n + 1) ∧ Nat.Prime p
⊢ p ∣ Nat.choose (m + n) m
Theorem: LieIdeal.map_eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← le_bot_iff]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I = ⊥ ↔ I ≤ LieHom.ker f

tactic: exact LieIdeal.map_le_iff_le_comap
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I ≤ ⊥ ↔ I ≤ LieHom.ker f
Theorem: Real.sin_nonneg_of_mem_Icc
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← closure_Ioo pi_ne_zero.symm] at hx
state_before: x : ℝ
hx : x ∈ Icc 0 π
⊢ 0 ≤ sin x

tactic: exact
  closure_lt_subset_le continuous_const continuous_sin
    (closure_mono (fun y => sin_pos_of_mem_Ioo) hx)
state_before: x : ℝ
hx : x ∈ closure (Ioo 0 π)
⊢ 0 ≤ sin x
Theorem: IsPreconnected.iUnion_of_chain
File: Mathlib/Topology/Connected.lean

tactic: rw [inter_comm]
state_before: α : Type u
β : Type v
ι : Type ?u.10523
π : ι → Type ?u.10528
inst✝³ : TopologicalSpace α
s✝ t u v : Set α
inst✝² : LinearOrder β
inst✝¹ : SuccOrder β
inst✝ : IsSuccArchimedean β
s : β → Set α
H : ∀ (n : β), IsPreconnected (s n)
K : ∀ (n : β), Set.Nonempty (s n ∩ s (succ n))
i✝ j i : β
x✝ : i ∈ Ico j i✝
⊢ Set.Nonempty (s (succ i) ∩ s i)

tactic: exact K i
state_before: α : Type u
β : Type v
ι : Type ?u.10523
π : ι → Type ?u.10528
inst✝³ : TopologicalSpace α
s✝ t u v : Set α
inst✝² : LinearOrder β
inst✝¹ : SuccOrder β
inst✝ : IsSuccArchimedean β
s : β → Set α
H : ∀ (n : β), IsPreconnected (s n)
K : ∀ (n : β), Set.Nonempty (s n ∩ s (succ n))
i✝ j i : β
x✝ : i ∈ Ico j i✝
⊢ Set.Nonempty (s i ∩ s (succ i))
Theorem: Finset.weightedVSubVSubWeights_apply_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [weightedVSubVSubWeights, hi, hj]
state_before: k : Type u_2
V : Type ?u.424095
P : Type ?u.424098
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.424754
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j t : ι
hi : t ≠ i
hj : t ≠ j
⊢ weightedVSubVSubWeights k i j t = 0
Theorem: Cardinal.beth_strictMono
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: intro a b
state_before: ⊢ StrictMono beth

tactic: induction' b using Ordinal.induction with b IH generalizing a
state_before: a b : Ordinal
⊢ a < b → beth a < beth b

tactic: intro h
state_before: case h
a✝ b : Ordinal
IH : ∀ (k : Ordinal), k < b → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
a : Ordinal
⊢ a < b → beth a < beth b

tactic: rcases zero_or_succ_or_limit b with (rfl | ⟨c, rfl⟩ | hb)
state_before: case h
a✝ b : Ordinal
IH : ∀ (k : Ordinal), k < b → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
a : Ordinal
h : a < b
⊢ beth a < beth b

tactic: exact (Ordinal.not_lt_zero a h).elim
state_before: case h.inl
a✝ a : Ordinal
IH : ∀ (k : Ordinal), k < 0 → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a < 0
⊢ beth a < beth 0

tactic: rw [lt_succ_iff] at h
state_before: case h.inr.inl.intro
a✝ a c : Ordinal
IH : ∀ (k : Ordinal), k < succ c → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a < succ c
⊢ beth a < beth (succ c)

tactic: rw [beth_succ]
state_before: case h.inr.inl.intro
a✝ a c : Ordinal
IH : ∀ (k : Ordinal), k < succ c → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a ≤ c
⊢ beth a < beth (succ c)

tactic: apply lt_of_le_of_lt _ (cantor _)
state_before: case h.inr.inl.intro
a✝ a c : Ordinal
IH : ∀ (k : Ordinal), k < succ c → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a ≤ c
⊢ beth a < 2 ^ beth c

tactic: rcases eq_or_lt_of_le h with (rfl | h)
state_before: a✝ a c : Ordinal
IH : ∀ (k : Ordinal), k < succ c → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a ≤ c
⊢ beth a ≤ beth c

tactic: exact (IH c (lt_succ c) h).le
state_before: case inr
a✝ a c : Ordinal
IH : ∀ (k : Ordinal), k < succ c → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h✝ : a ≤ c
h : a < c
⊢ beth a ≤ beth c

tactic: rfl
state_before: case inl
a✝ a : Ordinal
IH : ∀ (k : Ordinal), k < succ a → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
h : a ≤ a
⊢ beth a ≤ beth a

tactic: apply (cantor _).trans_le
state_before: case h.inr.inr
a✝ b : Ordinal
IH : ∀ (k : Ordinal), k < b → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
a : Ordinal
h : a < b
hb : Ordinal.IsLimit b
⊢ beth a < beth b

tactic: rw [beth_limit hb, ← beth_succ]
state_before: case h.inr.inr
a✝ b : Ordinal
IH : ∀ (k : Ordinal), k < b → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
a : Ordinal
h : a < b
hb : Ordinal.IsLimit b
⊢ 2 ^ beth a ≤ beth b

tactic: exact le_ciSup (bddAbove_of_small _) (⟨_, hb.succ_lt h⟩ : Iio b)
state_before: case h.inr.inr
a✝ b : Ordinal
IH : ∀ (k : Ordinal), k < b → ∀ ⦃a : Ordinal⦄, a < k → beth a < beth k
a : Ordinal
h : a < b
hb : Ordinal.IsLimit b
⊢ beth (succ a) ≤ ⨆ (a : ↑(Iio b)), beth ↑a