tasksource/leandojo huggingface dataset:
Theorem: Nat.lt_div_iff_mul_lt
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rcases d.eq_zero_or_pos with (rfl | hd0)
state_before: a✝ b m n✝ k n d : ℕ
hnd : d ∣ n
a : ℕ
⊢ a < n / d ↔ d * a < n

tactic: rw [← mul_lt_mul_left hd0, ← Nat.eq_mul_of_div_eq_right hnd rfl]
state_before: case inr
a✝ b m n✝ k n d : ℕ
hnd : d ∣ n
a : ℕ
hd0 : d > 0
⊢ a < n / d ↔ d * a < n

tactic: simp [zero_dvd_iff.mp hnd]
state_before: case inl
a✝ b m n✝ k n a : ℕ
hnd : 0 ∣ n
⊢ a < n / 0 ↔ 0 * a < n
Theorem: Set.toFinset_symmDiff
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.89359
γ : Type ?u.89362
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∆ t)
⊢ toFinset (s ∆ t) = toFinset s ∆ toFinset t

tactic: simp [mem_symmDiff, Finset.mem_symmDiff]
state_before: case a
α : Type u_1
β : Type ?u.89359
γ : Type ?u.89362
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∆ t)
a✝ : α
⊢ a✝ ∈ toFinset (s ∆ t) ↔ a✝ ∈ toFinset s ∆ toFinset t
Theorem: Metric.uniformity_basis_dist_inv_nat_pos
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: exact_mod_cast hn.le
state_before: α : Type u
β : Type v
X : Type ?u.52437
ι : Type ?u.52440
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
ε0 : 0 < ε
n : ℕ
hn : 1 / (↑n + 1) < ε
⊢ 1 / ↑(n + 1) ≤ ε
Theorem: Finset.Nat.filter_snd_eq_antidiagonal
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: have : (fun x : ℕ × ℕ ↦ (x.snd = m)) ∘ Prod.swap = fun x : ℕ × ℕ ↦ x.fst = m := by
  ext ; simp
state_before: n m : ℕ
⊢ filter (fun x => x.snd = m) (antidiagonal n) = if m ≤ n then {(n - m, m)} else ∅

tactic: rw [← map_swap_antidiagonal]
state_before: n m : ℕ
this : (fun x => x.snd = m) ∘ Prod.swap = fun x => x.fst = m
⊢ filter (fun x => x.snd = m) (antidiagonal n) = if m ≤ n then {(n - m, m)} else ∅

tactic: simp [filter_map, this, filter_fst_eq_antidiagonal, apply_ite (Finset.map _)]
state_before: n m : ℕ
this : (fun x => x.snd = m) ∘ Prod.swap = fun x => x.fst = m
⊢ filter (fun x => x.snd = m)
      (map { toFun := Prod.swap, inj' := (_ : Function.Injective Prod.swap) } (antidiagonal n)) =
    if m ≤ n then {(n - m, m)} else ∅

tactic: ext
state_before: n m : ℕ
⊢ (fun x => x.snd = m) ∘ Prod.swap = fun x => x.fst = m

tactic: simp
state_before: case h.a
n m : ℕ
x✝ : ℕ × ℕ
⊢ ((fun x => x.snd = m) ∘ Prod.swap) x✝ ↔ x✝.fst = m
Theorem: ultrafilterBasis_is_basis
File: Mathlib/Topology/StoneCech.lean

tactic: rintro _ ⟨a, rfl⟩ _ ⟨b, rfl⟩ u ⟨ua, ub⟩
state_before: α : Type u
⊢ ∀ (t₁ : Set (Ultrafilter α)),
    t₁ ∈ ultrafilterBasis α →
      ∀ (t₂ : Set (Ultrafilter α)),
        t₂ ∈ ultrafilterBasis α →
          ∀ (x : Ultrafilter α), x ∈ t₁ ∩ t₂ → ∃ t₃, t₃ ∈ ultrafilterBasis α ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: refine' ⟨_, ⟨a ∩ b, rfl⟩, inter_mem ua ub, fun v hv => ⟨_, _⟩⟩ <;> apply mem_of_superset hv <;>
  simp [inter_subset_right a b]
state_before: case intro.intro.intro
α : Type u
a b : Set α
u : Ultrafilter α
ua : u ∈ (fun s => {u | s ∈ u}) a
ub : u ∈ (fun s => {u | s ∈ u}) b
⊢ ∃ t₃, t₃ ∈ ultrafilterBasis α ∧ u ∈ t₃ ∧ t₃ ⊆ (fun s => {u | s ∈ u}) a ∩ (fun s => {u | s ∈ u}) b
Theorem: AffineMap.hasStrictDerivAt_lineMap
File: Mathlib/Analysis/Calculus/Deriv/AffineMap.lean

tactic: simpa using (lineMap a b : 𝕜 →ᵃ[𝕜] E).hasStrictDerivAt
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 →ᵃ[𝕜] E
a b : E
L : Filter 𝕜
s : Set 𝕜
x : 𝕜
⊢ HasStrictDerivAt (↑(lineMap a b)) (b - a) x
Theorem: Stirling.stirlingSeq'_pos
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: unfold stirlingSeq
state_before: n : ℕ
⊢ 0 < stirlingSeq (succ n)

tactic: positivity
state_before: n : ℕ
⊢ 0 < ↑(succ n)! / (Real.sqrt (2 * ↑(succ n)) * (↑(succ n) / exp 1) ^ succ n)
Theorem: LieSubmodule.ucs_eq_top_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: rw [eq_top_iff, ← lcs_le_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ ucs k N = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ lcs k ⊤ ≤ N ↔ LieModule.lowerCentralSeries R L M k ≤ N
Theorem: Convex.mem_to_cone'
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: refine' hs.mem_toCone.trans ⟨_, _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
⊢ x ∈ toCone s hs ↔ ∃ c, 0 < c ∧ c • x ∈ s

tactic: rintro ⟨c, hc, y, hy, rfl⟩
state_before: case refine'_1
𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
⊢ (∃ c, 0 < c ∧ ∃ y, y ∈ s ∧ c • y = x) → ∃ c, 0 < c ∧ c • x ∈ s

tactic: exact ⟨c⁻¹, inv_pos.2 hc, by rwa [smul_smul, inv_mul_cancel hc.ne', one_smul]⟩
state_before: case refine'_1.intro.intro.intro.intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
c : 𝕜
hc : 0 < c
y : E
hy : y ∈ s
⊢ ∃ c_1, 0 < c_1 ∧ c_1 • c • y ∈ s

tactic: rwa [smul_smul, inv_mul_cancel hc.ne', one_smul]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
c : 𝕜
hc : 0 < c
y : E
hy : y ∈ s
⊢ c⁻¹ • c • y ∈ s

tactic: rintro ⟨c, hc, hcx⟩
state_before: case refine'_2
𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
⊢ (∃ c, 0 < c ∧ c • x ∈ s) → ∃ c, 0 < c ∧ ∃ y, y ∈ s ∧ c • y = x

tactic: exact ⟨c⁻¹, inv_pos.2 hc, _, hcx, by rw [smul_smul, inv_mul_cancel hc.ne', one_smul]⟩
state_before: case refine'_2.intro.intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
c : 𝕜
hc : 0 < c
hcx : c • x ∈ s
⊢ ∃ c, 0 < c ∧ ∃ y, y ∈ s ∧ c • y = x

tactic: rw [smul_smul, inv_mul_cancel hc.ne', one_smul]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.167255
G : Type ?u.167258
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
c : 𝕜
hc : 0 < c
hcx : c • x ∈ s
⊢ c⁻¹ • c • x = x
Theorem: Ideal.homogeneousHull_eq_iSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rintro _ ⟨x, -, rfl⟩
state_before: ι : Type ?u.242952
σ : Type ?u.242955
R : Type ?u.242958
A : Type ?u.242961
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
i : ι
⊢ ∀ (x : A), x ∈ ↑(GradedRing.proj 𝒜 i) '' ↑I → Homogeneous 𝒜 x

tactic: apply SetLike.homogeneous_coe
state_before: case intro.intro
ι : Type ?u.242952
σ : Type ?u.242955
R : Type ?u.242958
A : Type ?u.242961
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
i : ι
x : A
⊢ Homogeneous 𝒜 (↑(GradedRing.proj 𝒜 i) x)

tactic: ext1
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.242958
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ homogeneousHull 𝒜 I =
    ⨆ (i : ι),
      { toSubmodule := span (↑(GradedRing.proj 𝒜 i) '' ↑I),
        is_homogeneous' := (_ : IsHomogeneous 𝒜 (span (↑(GradedRing.proj 𝒜 i) '' ↑I))) }

tactic: rw [Ideal.toIdeal_homogeneousHull_eq_iSup, toIdeal_iSup]
state_before: case h
ι : Type u_2
σ : Type u_3
R : Type ?u.242958
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ toIdeal (homogeneousHull 𝒜 I) =
    toIdeal
      (⨆ (i : ι),
        { toSubmodule := span (↑(GradedRing.proj 𝒜 i) '' ↑I),
          is_homogeneous' := (_ : IsHomogeneous 𝒜 (span (↑(GradedRing.proj 𝒜 i) '' ↑I))) })

tactic: rfl
state_before: case h
ι : Type u_2
σ : Type u_3
R : Type ?u.242958
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
⊢ (⨆ (i : ι), span (↑(GradedRing.proj 𝒜 i) '' ↑I)) =
    ⨆ (i : ι),
      toIdeal
        { toSubmodule := span (↑(GradedRing.proj 𝒜 i) '' ↑I),
          is_homogeneous' := (_ : IsHomogeneous 𝒜 (span (↑(GradedRing.proj 𝒜 i) '' ↑I))) }
Theorem: nhdsWithin_Icc_eq_nhdsWithin_Iic
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [dual_Icc] using nhdsWithin_Icc_eq_nhdsWithin_Ici h.dual
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
a✝ b✝ : α
inst✝ : TopologicalSpace γ
a b : α
h : a < b
⊢ 𝓝[Icc a b] b = 𝓝[Iic b] b
Theorem: EckmannHilton.mul
File: Mathlib/GroupTheory/EckmannHilton.lean

tactic: funext a b
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
⊢ m₁ = m₂

tactic: calc
  m₁ a b = m₁ (m₂ a e₁) (m₂ e₁ b) := by
    { simp only [one h₁ h₂ distrib, h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id] }
  _ = m₂ a b := by simp only [distrib, h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id]
state_before: case h.h
X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b : X
⊢ m₁ a b = m₂ a b

tactic: simp only [distrib, h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id]
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b : X
⊢ m₁ (m₂ a e₁) (m₂ e₁ b) = m₂ a b
Theorem: ContinuousMultilinearMap.le_op_nnnorm
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: push_cast
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type ?u.537533
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
⊢ ↑‖↑f m‖₊ ≤ ↑(‖f‖₊ * ∏ i : ι, ‖m i‖₊)

tactic: exact f.le_op_norm m
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type ?u.537533
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
⊢ ‖↑f m‖ ≤ ‖f‖ * ∏ x : ι, ‖m x‖
Theorem: Set.Intersecting.insert
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: rintro b (rfl | hb) c (rfl | hc)
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
hs : Intersecting s
ha : a ≠ ⊥
h : ∀ (b : α), b ∈ s → ¬Disjoint a b
⊢ Intersecting (Insert.insert a s)

tactic: rwa [disjoint_self]
state_before: case inl.inl
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
b c✝ : α
hs : Intersecting s
c : α
ha : c ≠ ⊥
h : ∀ (b : α), b ∈ s → ¬Disjoint c b
⊢ ¬Disjoint c c

tactic: exact h _ hc
state_before: case inl.inr
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
b✝ c✝ : α
hs : Intersecting s
b : α
ha : b ≠ ⊥
h : ∀ (b_1 : α), b_1 ∈ s → ¬Disjoint b b_1
c : α
hc : c ∈ s
⊢ ¬Disjoint b c

tactic: exact fun H => h _ hb H.symm
state_before: case inr.inl
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
b✝ c✝ : α
hs : Intersecting s
b : α
hb : b ∈ s
c : α
ha : c ≠ ⊥
h : ∀ (b : α), b ∈ s → ¬Disjoint c b
⊢ ¬Disjoint b c

tactic: exact hs hb hc
state_before: case inr.inr
α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b✝ c✝ : α
hs : Intersecting s
ha : a ≠ ⊥
h : ∀ (b : α), b ∈ s → ¬Disjoint a b
b : α
hb : b ∈ s
c : α
hc : c ∈ s
⊢ ¬Disjoint b c
Theorem: Complex.normSq_neg
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [normSq]
state_before: z : ℂ
⊢ ↑normSq (-z) = ↑normSq z
Theorem: Finset.Ico_erase_left
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj]
state_before: ι : Type ?u.81143
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ erase (Ico a b) a = Ioo a b
Theorem: Finset.memberSubfamily_inter
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: unfold memberSubfamily
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ memberSubfamily a (𝒜 ∩ ℬ) = memberSubfamily a 𝒜 ∩ memberSubfamily a ℬ

tactic: rw [filter_inter_distrib, image_inter_of_injOn _ _ ((erase_injOn' _).mono _)]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ image (fun s => erase s a) (filter (fun s => a ∈ s) (𝒜 ∩ ℬ)) =
    image (fun s => erase s a) (filter (fun s => a ∈ s) 𝒜) ∩ image (fun s => erase s a) (filter (fun s => a ∈ s) ℬ)

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ ↑(filter (fun s => a ∈ s) 𝒜) ∪ ↑(filter (fun s => a ∈ s) ℬ) ⊆ {s | a ∈ s}
Theorem: LinearPMap.sup_h_of_disjoint
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rw [disjoint_def] at h
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.210345
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : Disjoint f.domain g.domain
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y

tactic: have hy : y = 0 := Subtype.eq (h y (hxy ▸ x.2) y.2)
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.210345
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
⊢ ↑f x = ↑g y

tactic: have hx : x = 0 := Subtype.eq (hxy.trans <| congr_arg _ hy)
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.210345
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
hy : y = 0
⊢ ↑f x = ↑g y

tactic: simp [*]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.210345
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : E), x ∈ f.domain → x ∈ g.domain → x = 0
x : { x // x ∈ f.domain }
y : { x // x ∈ g.domain }
hxy : ↑x = ↑y
hy : y = 0
hx : x = 0
⊢ ↑f x = ↑g y
Theorem: Order.not_isPredLimit_of_noMin
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp
state_before: α : Type u_1
inst✝⁴ : Preorder α
a : α
inst✝³ : PredOrder α
inst✝² : IsPredArchimedean α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
⊢ ¬IsPredLimit a
Theorem: Order.Ideal.IsPrime.of_mem_or_mem
File: Mathlib/Order/PrimeIdeal.lean

tactic: rw [IsPrime_iff]
state_before: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ IsPrime I

tactic: use ‹_›
state_before: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ IsProper I ∧ IsPFilter (↑Iᶜ)

tactic: refine .of_def ?_ ?_ ?_
state_before: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ IsPFilter (↑Iᶜ)

tactic: exact Set.nonempty_compl.2 (I.IsProper_iff.1 ‹_›)
state_before: case refine_1
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ Set.Nonempty (↑Iᶜ)

tactic: intro x hx y hy
state_before: case refine_2
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ DirectedOn (fun x x_1 => x ≥ x_1) (↑Iᶜ)

tactic: exact ⟨x ⊓ y, fun h => (hI h).elim hx hy, inf_le_left, inf_le_right⟩
state_before: case refine_2
P : Type u_1
inst✝¹ : SemilatticeInf P
x✝ y✝ : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
x : P
hx : x ∈ ↑Iᶜ
y : P
hy : y ∈ ↑Iᶜ
⊢ ∃ z, z ∈ ↑Iᶜ ∧ (fun x x_1 => x ≥ x_1) x z ∧ (fun x x_1 => x ≥ x_1) y z

tactic: exact @mem_compl_of_ge _ _ _
state_before: case refine_3
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : IsProper I
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ ∀ {x y : P}, x ≤ y → x ∈ ↑Iᶜ → y ∈ ↑Iᶜ
Theorem: FreeProduct.NeWord.toList_head?
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: rw [← Option.mem_def]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ List.head? (toList w) = some { fst := i, snd := head w }

tactic: induction w
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ { fst := i, snd := head w } ∈ List.head? (toList w)

tactic: rw [Option.mem_def]
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ { fst := i✝, snd := head (singleton x✝ a✝) } ∈ List.head? (toList (singleton x✝ a✝))

tactic: rfl
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ List.head? (toList (singleton x✝ a✝)) = some { fst := i✝, snd := head (singleton x✝ a✝) }

tactic: exact List.head?_append (by assumption)
state_before: case append
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : { fst := i✝, snd := head _w₁✝ } ∈ List.head? (toList _w₁✝)
_w₂_ih✝ : { fst := k✝, snd := head _w₂✝ } ∈ List.head? (toList _w₂✝)
⊢ { fst := i✝, snd := head (append _w₁✝ _hne✝ _w₂✝) } ∈ List.head? (toList (append _w₁✝ _hne✝ _w₂✝))

tactic: assumption
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.490383
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : { fst := i✝, snd := head _w₁✝ } ∈ List.head? (toList _w₁✝)
_w₂_ih✝ : { fst := k✝, snd := head _w₂✝ } ∈ List.head? (toList _w₂✝)
⊢ { fst := i✝, snd := head (append _w₁✝ _hne✝ _w₂✝) } ∈ List.head? (toList _w₁✝)
Theorem: LieSubmodule.subset_lieSpan
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: intro m hm
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ s ⊆ ↑(lieSpan R L s)

tactic: erw [mem_lieSpan]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ m ∈ ↑(lieSpan R L s)

tactic: intro N hN
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → m ∈ N

tactic: exact hN hm
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
N : LieSubmodule R L M
hN : s ⊆ ↑N
⊢ m ∈ N
Theorem: Subgroup.iSup_eq_closure
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp_rw [closure_iUnion, closure_eq]
state_before: G : Type u_2
G' : Type ?u.215948
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.215957
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
ι : Sort u_1
p : ι → Subgroup G
⊢ (⨆ (i : ι), p i) = closure (⋃ (i : ι), ↑(p i))
Theorem: Int.le_toNat
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.ofNat_le, Int.toNat_of_nonneg h]
state_before: n : Nat
z : Int
h : 0 ≤ z
⊢ n ≤ toNat z ↔ ↑n ≤ z
Theorem: Complex.exp_eq_exp_re_mul_sin_add_cos
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← exp_add_mul_I, re_add_im]
state_before: x y : ℂ
⊢ exp x = exp ↑x.re * (cos ↑x.im + sin ↑x.im * I)
Theorem: Matrix.transpose_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.928657
m : Type u_2
n : Type u_3
o : Type ?u.928666
m' : o → Type ?u.928671
n' : o → Type ?u.928676
R✝ : Type ?u.928679
S : Type ?u.928682
α : Type v
β : Type w
γ : Type ?u.928689
R : Type u_1
inst✝ : SMul R α
c : R
M : Matrix m n α
⊢ (c • M)ᵀ = c • Mᵀ

tactic: rfl
state_before: case a.h
l : Type ?u.928657
m : Type u_2
n : Type u_3
o : Type ?u.928666
m' : o → Type ?u.928671
n' : o → Type ?u.928676
R✝ : Type ?u.928679
S : Type ?u.928682
α : Type v
β : Type w
γ : Type ?u.928689
R : Type u_1
inst✝ : SMul R α
c : R
M : Matrix m n α
i✝ : n
x✝ : m
⊢ (c • M)ᵀ i✝ x✝ = (c • Mᵀ) i✝ x✝
Theorem: Finsupp.single_swap
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical simp only [single_apply, eq_comm]
state_before: α : Type u_2
β : Type ?u.130294
γ : Type ?u.130297
ι : Type ?u.130300
M : Type u_1
M' : Type ?u.130306
N : Type ?u.130309
P : Type ?u.130312
G : Type ?u.130315
H : Type ?u.130318
R : Type ?u.130321
S : Type ?u.130324
inst✝ : Zero M
a a' : α
b✝ : M
a₁ a₂ : α
b : M
⊢ ↑(single a₁ b) a₂ = ↑(single a₂ b) a₁

tactic: simp only [single_apply, eq_comm]
state_before: α : Type u_2
β : Type ?u.130294
γ : Type ?u.130297
ι : Type ?u.130300
M : Type u_1
M' : Type ?u.130306
N : Type ?u.130309
P : Type ?u.130312
G : Type ?u.130315
H : Type ?u.130318
R : Type ?u.130321
S : Type ?u.130324
inst✝ : Zero M
a a' : α
b✝ : M
a₁ a₂ : α
b : M
⊢ ↑(single a₁ b) a₂ = ↑(single a₂ b) a₁