tasksource/leandojo huggingface dataset:
Theorem: Set.subset_iInter₂_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [subset_iInter_iff]
state_before: α : Type u_1
β : Type ?u.60356
γ : Type ?u.60359
ι : Sort u_2
ι' : Sort ?u.60365
ι₂ : Sort ?u.60368
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.60378
κ₂ : ι → Sort ?u.60383
κ' : ι' → Sort ?u.60388
s : Set α
t : (i : ι) → κ i → Set α
⊢ (s ⊆ ⋂ (i : ι) (j : κ i), t i j) ↔ ∀ (i : ι) (j : κ i), s ⊆ t i j
Theorem: Equiv.Perm.closure_isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: classical
  cases nonempty_fintype β
  exact
    top_le_iff.mp (le_trans (ge_of_eq closure_isSwap) (closure_mono fun _ => IsSwap.isCycle))
state_before: ι : Type ?u.2795604
α : Type ?u.2795607
β : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Finite β
⊢ closure {σ | IsCycle σ} = ⊤

tactic: cases nonempty_fintype β
state_before: ι : Type ?u.2795604
α : Type ?u.2795607
β : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Finite β
⊢ closure {σ | IsCycle σ} = ⊤

tactic: exact
  top_le_iff.mp (le_trans (ge_of_eq closure_isSwap) (closure_mono fun _ => IsSwap.isCycle))
state_before: case intro
ι : Type ?u.2795604
α : Type ?u.2795607
β : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Finite β
val✝ : Fintype β
⊢ closure {σ | IsCycle σ} = ⊤
Theorem: Option.pmap_eq_some_iff
File: Mathlib/Data/Option/Basic.lean

tactic: rcases x with (_|x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
x : Option α
hf : ∀ (a : α), a ∈ x → p a
y : β
⊢ pmap f x hf = some y ↔ ∃ a H, f a (_ : p a) = y

tactic: simp only [not_mem_none, exists_false, pmap, not_false_iff, exists_prop_of_false]
state_before: case none
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
hf : ∀ (a : α), a ∈ none → p a
⊢ pmap f none hf = some y ↔ ∃ a H, f a (_ : p a) = y

tactic: constructor
state_before: case some
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
x : α
hf : ∀ (a : α), a ∈ some x → p a
⊢ pmap f (some x) hf = some y ↔ ∃ a H, f a (_ : p a) = y

tactic: intro h
state_before: case some.mp
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
x : α
hf : ∀ (a : α), a ∈ some x → p a
⊢ pmap f (some x) hf = some y → ∃ a H, f a (_ : p a) = y

tactic: simp only [pmap, Option.some_inj] at h
state_before: case some.mp
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
x : α
hf : ∀ (a : α), a ∈ some x → p a
h : pmap f (some x) hf = some y
⊢ ∃ a H, f a (_ : p a) = y

tactic: refine ⟨x, rfl, h⟩
state_before: case some.mp
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
x : α
hf : ∀ (a : α), a ∈ some x → p a
h : f x (_ : p x) = y
⊢ ∃ a H, f a (_ : p a) = y

tactic: rintro ⟨a, H, rfl⟩
state_before: case some.mpr
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
y : β
x : α
hf : ∀ (a : α), a ∈ some x → p a
⊢ (∃ a H, f a (_ : p a) = y) → pmap f (some x) hf = some y

tactic: simp only [mem_def, Option.some_inj] at H
state_before: case some.mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
x : α
hf : ∀ (a : α), a ∈ some x → p a
a : α
H : some x = some a
⊢ pmap f (some x) hf = some (f a (_ : p a))

tactic: simp only [H, pmap]
state_before: case some.mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.12874
δ : Type ?u.12877
p : α → Prop
f : (a : α) → p a → β
x : α
hf : ∀ (a : α), a ∈ some x → p a
a : α
H✝ : some x = some a
H : x = a
⊢ pmap f (some x) hf = some (f a (_ : p a))
Theorem: Multiset.mem_powersetLenAux
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetLenAux_eq_map_coe, Subperm]
state_before: α : Type u_1
n : ℕ
l : List α
s : Multiset α
⊢ ∀ (a : List α),
    Quotient.mk (isSetoid α) a ∈ powersetLenAux n l ↔
      Quotient.mk (isSetoid α) a ≤ ↑l ∧ ↑card (Quotient.mk (isSetoid α) a) = n

tactic: exact fun l₁ =>
  ⟨fun ⟨l₂, ⟨s, e⟩, p⟩ => ⟨⟨_, p, s⟩, p.symm.length_eq.trans e⟩,
   fun ⟨⟨l₂, p, s⟩, e⟩ => ⟨_, ⟨s, p.length_eq.trans e⟩, p⟩⟩
state_before: α : Type u_1
n : ℕ
l : List α
s : Multiset α
⊢ ∀ (a : List α), (∃ a_1, (a_1 <+ l ∧ length a_1 = n) ∧ a_1 ~ a) ↔ (∃ l_1, l_1 ~ a ∧ l_1 <+ l) ∧ length a = n
Theorem: Finset.image₂_subset
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [← coe_subset, coe_image₂, coe_image₂]
state_before: α : Type u_1
α' : Type ?u.12205
β : Type u_2
β' : Type ?u.12211
γ : Type u_3
γ' : Type ?u.12217
δ : Type ?u.12220
δ' : Type ?u.12223
ε : Type ?u.12226
ε' : Type ?u.12229
ζ : Type ?u.12232
ζ' : Type ?u.12235
ν : Type ?u.12238
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hs : s ⊆ s'
ht : t ⊆ t'
⊢ image₂ f s t ⊆ image₂ f s' t'

tactic: exact image2_subset hs ht
state_before: α : Type u_1
α' : Type ?u.12205
β : Type u_2
β' : Type ?u.12211
γ : Type u_3
γ' : Type ?u.12217
δ : Type ?u.12220
δ' : Type ?u.12223
ε : Type ?u.12226
ε' : Type ?u.12229
ζ : Type ?u.12232
ζ' : Type ?u.12235
ν : Type ?u.12238
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hs : s ⊆ s'
ht : t ⊆ t'
⊢ image2 f ↑s ↑t ⊆ image2 f ↑s' ↑t'
Theorem: Basis.toDual_total_left
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [Finsupp.total_apply, Finsupp.sum, LinearMap.map_sum, LinearMap.sum_apply]
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ ↑(↑(toDual b) (↑(Finsupp.total ι M R ↑b) f)) (↑b i) = ↑f i

tactic: simp_rw [LinearMap.map_smul, LinearMap.smul_apply, toDual_apply, smul_eq_mul, mul_boole,
  Finset.sum_ite_eq']
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ ∑ d in f.support, ↑(↑(toDual b) (↑f d • ↑b d)) (↑b i) = ↑f i

tactic: split_ifs with h
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ (if i ∈ f.support then ↑f i else 0) = ↑f i

tactic: rfl
state_before: case inl
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
h : i ∈ f.support
⊢ ↑f i = ↑f i

tactic: rw [Finsupp.not_mem_support_iff.mp h]
state_before: case inr
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
h : ¬i ∈ f.support
⊢ 0 = ↑f i
Theorem: norm_le_norm_add_norm_div'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [add_comm]
state_before: 𝓕 : Type ?u.85510
𝕜 : Type ?u.85513
α : Type ?u.85516
ι : Type ?u.85519
κ : Type ?u.85522
E : Type u_1
F : Type ?u.85528
G : Type ?u.85531
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖u‖ ≤ ‖v‖ + ‖u / v‖

tactic: refine' (norm_mul_le' _ _).trans_eq' _
state_before: 𝓕 : Type ?u.85510
𝕜 : Type ?u.85513
α : Type ?u.85516
ι : Type ?u.85519
κ : Type ?u.85522
E : Type u_1
F : Type ?u.85528
G : Type ?u.85531
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖u‖ ≤ ‖u / v‖ + ‖v‖

tactic: rw [div_mul_cancel']
state_before: 𝓕 : Type ?u.85510
𝕜 : Type ?u.85513
α : Type ?u.85516
ι : Type ?u.85519
κ : Type ?u.85522
E : Type u_1
F : Type ?u.85528
G : Type ?u.85531
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖u‖ = ‖u / v * v‖
Theorem: tendsto_inf_principal_nhds_iff_of_forall_eq
File: Mathlib/Topology/Basic.lean

tactic: rw [tendsto_iff_comap, tendsto_iff_comap]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : ∀ (x : β), ¬x ∈ s → f x = a
⊢ Tendsto f (l ⊓ 𝓟 s) (𝓝 a) ↔ Tendsto f l (𝓝 a)

tactic: replace h : 𝓟 (sᶜ) ≤ comap f (𝓝 a)
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : ∀ (x : β), ¬x ∈ s → f x = a
⊢ l ⊓ 𝓟 s ≤ comap f (𝓝 a) ↔ l ≤ comap f (𝓝 a)

tactic: refine' ⟨fun h' => _, le_trans inf_le_left⟩
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : 𝓟 (sᶜ) ≤ comap f (𝓝 a)
⊢ l ⊓ 𝓟 s ≤ comap f (𝓝 a) ↔ l ≤ comap f (𝓝 a)

tactic: have := sup_le h' h
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : 𝓟 (sᶜ) ≤ comap f (𝓝 a)
h' : l ⊓ 𝓟 s ≤ comap f (𝓝 a)
⊢ l ≤ comap f (𝓝 a)

tactic: rw [sup_inf_right, sup_principal, union_compl_self, principal_univ, inf_top_eq, sup_le_iff]
  at this
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : 𝓟 (sᶜ) ≤ comap f (𝓝 a)
h' : l ⊓ 𝓟 s ≤ comap f (𝓝 a)
this : l ⊓ 𝓟 s ⊔ 𝓟 (sᶜ) ≤ comap f (𝓝 a)
⊢ l ≤ comap f (𝓝 a)

tactic: exact this.1
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : 𝓟 (sᶜ) ≤ comap f (𝓝 a)
h' : l ⊓ 𝓟 s ≤ comap f (𝓝 a)
this : l ≤ comap f (𝓝 a) ∧ 𝓟 (sᶜ) ≤ comap f (𝓝 a)
⊢ l ≤ comap f (𝓝 a)

tactic: rintro U ⟨t, ht, htU⟩ x hx
state_before: case h
α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : ∀ (x : β), ¬x ∈ s → f x = a
⊢ 𝓟 (sᶜ) ≤ comap f (𝓝 a)

tactic: have : f x ∈ t := (h x hx).symm ▸ mem_of_mem_nhds ht
state_before: case h.intro.intro
α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : ∀ (x : β), ¬x ∈ s → f x = a
U : Set β
t : Set α
ht : t ∈ 𝓝 a
htU : f ⁻¹' t ⊆ U
x : β
hx : x ∈ sᶜ
⊢ x ∈ U

tactic: exact htU this
state_before: case h.intro.intro
α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : β → α
l : Filter β
s : Set β
a : α
h : ∀ (x : β), ¬x ∈ s → f x = a
U : Set β
t : Set α
ht : t ∈ 𝓝 a
htU : f ⁻¹' t ⊆ U
x : β
hx : x ∈ sᶜ
this : f x ∈ t
⊢ x ∈ U
Theorem: UpperSet.coe_eq_empty
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [SetLike.ext'_iff]
state_before: α : Type u_1
β : Type ?u.46281
γ : Type ?u.46284
ι : Sort ?u.46287
κ : ι → Sort ?u.46292
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
⊢ ↑s = ∅ ↔ s = ⊤
Theorem: Nat.sub_eq_iff_eq_add
File: Std/Data/Nat/Lemmas.lean

tactic: rw [c_eq.symm, Nat.sub_add_cancel ab]
state_before: a b c : Nat
ab : b ≤ a
c_eq : a - b = c
⊢ a = c + b

tactic: rw [a_eq, Nat.add_sub_cancel]
state_before: a b c : Nat
ab : b ≤ a
a_eq : a = c + b
⊢ a - b = c
Theorem: IsLocalization.sec_fst_ne_zero
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: have hsec := sec_spec M x
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
P : Type ?u.3066574
inst✝³ : CommRing P
K : Type ?u.3066580
inst✝² : IsLocalization M S
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors S
hM : M ≤ nonZeroDivisors R
x : S
hx : x ≠ 0
⊢ (sec M x).fst ≠ 0

tactic: intro hfst
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
P : Type ?u.3066574
inst✝³ : CommRing P
K : Type ?u.3066580
inst✝² : IsLocalization M S
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors S
hM : M ≤ nonZeroDivisors R
x : S
hx : x ≠ 0
hsec : x * ↑(algebraMap R S) ↑(sec M x).snd = ↑(algebraMap R S) (sec M x).fst
⊢ (sec M x).fst ≠ 0

tactic: rw [hfst, map_zero, mul_eq_zero, _root_.map_eq_zero_iff] at hsec
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
P : Type ?u.3066574
inst✝³ : CommRing P
K : Type ?u.3066580
inst✝² : IsLocalization M S
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors S
hM : M ≤ nonZeroDivisors R
x : S
hx : x ≠ 0
hsec : x * ↑(algebraMap R S) ↑(sec M x).snd = ↑(algebraMap R S) (sec M x).fst
hfst : (sec M x).fst = 0
⊢ False

tactic: exact Or.elim hsec hx (sec_snd_ne_zero hM x)
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
P : Type ?u.3066574
inst✝³ : CommRing P
K : Type ?u.3066580
inst✝² : IsLocalization M S
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors S
hM : M ≤ nonZeroDivisors R
x : S
hx : x ≠ 0
hsec : x = 0 ∨ ↑(sec M x).snd = 0
hfst : (sec M x).fst = 0
⊢ False

tactic: exact IsLocalization.injective S hM
state_before: case hf
R : Type u_1
inst✝⁶ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
P : Type ?u.3066574
inst✝³ : CommRing P
K : Type ?u.3066580
inst✝² : IsLocalization M S
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors S
hM : M ≤ nonZeroDivisors R
x : S
hx : x ≠ 0
hsec : x = 0 ∨ ↑(algebraMap R S) ↑(sec M x).snd = 0
hfst : (sec M x).fst = 0
⊢ Injective ↑(algebraMap R S)
Theorem: Set.Finite.inter_of_right
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
t : Set α
⊢ Set.Finite (t ∩ s)

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a✝ : Fintype ↑s
⊢ Set.Finite (t ∩ s)
Theorem: not_bddAbove_iff
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp only [not_bddAbove_iff', not_le]
state_before: α✝ : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α✝
inst✝¹ : Preorder β
s✝ t : Set α✝
a b : α✝
α : Type u_1
inst✝ : LinearOrder α
s : Set α
⊢ ¬BddAbove s ↔ ∀ (x : α), ∃ y, y ∈ s ∧ x < y
Theorem: Subgroup.commProb_quotient_le
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: rw [commProb_def', commProb_def', div_le_iff, mul_assoc, ← Nat.cast_mul, ← Subgroup.index,
  H.card_mul_index, div_mul_cancel, Nat.cast_le]
state_before: M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ commProb (G ⧸ H) ≤ commProb G * ↑(Nat.card { x // x ∈ H })

tactic: apply Finite.card_le_of_surjective
state_before: M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Nat.card (ConjClasses (G ⧸ H)) ≤ Nat.card (ConjClasses G)

tactic: show Function.Surjective (ConjClasses.map (QuotientGroup.mk' H))
state_before: case hf
M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Function.Surjective ?f

case f
M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ ConjClasses G → ConjClasses (G ⧸ H)

tactic: exact ConjClasses.map_surjective Quotient.surjective_Quotient_mk''
state_before: case hf
M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Function.Surjective (ConjClasses.map (QuotientGroup.mk' H))

tactic: exact Nat.cast_ne_zero.mpr Finite.card_pos.ne'
state_before: case h
M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ ↑(Nat.card G) ≠ 0

tactic: exact Nat.cast_pos.mpr Finite.card_pos
state_before: M : Type ?u.28957
inst✝⁵ : Mul M
inst✝⁴ : Finite M
G : Type u_1
inst✝³ : Group G
inst✝² : Finite G
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ 0 < ↑(Nat.card (G ⧸ H))
Theorem: List.prev_getLast_cons'
File: Mathlib/Data/List/Cycle.lean

tactic: cases l <;> simp [prev, hx]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hxy : x ∈ y :: l
hx : x = y
⊢ prev (y :: l) x hxy = getLast (y :: l) (_ : y :: l ≠ [])
Theorem: Quotient.mk_eq_iff_out
File: Mathlib/Data/Quot.lean

tactic: refine' Iff.trans _ Quotient.eq
state_before: α : Sort u_1
β : Sort ?u.34412
s : Setoid α
x : α
y : Quotient s
⊢ Quotient.mk s x = y ↔ x ≈ out y

tactic: rw [Quotient.out_eq y]
state_before: α : Sort u_1
β : Sort ?u.34412
s : Setoid α
x : α
y : Quotient s
⊢ Quotient.mk s x = y ↔ Quotient.mk s x = Quotient.mk s (out y)
Theorem: Module.forall_dual_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← eval_apply_eq_zero_iff K v, LinearMap.ext_iff]
state_before: K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
⊢ (∀ (φ : Dual K V), ↑φ v = 0) ↔ v = 0

tactic: rfl
state_before: K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
⊢ (∀ (φ : Dual K V), ↑φ v = 0) ↔ ∀ (x : Dual K V), ↑(↑(eval K V) v) x = ↑0 x
Theorem: ADEInequality.admissible_of_one_lt_sumInv
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: simp only [Admissible]
state_before: p q r : ℕ+
H : 1 < sumInv {p, q, r}
⊢ Admissible {p, q, r}

tactic: have hpqr : ({p, q, r} : Multiset ℕ+) = S := (sort_eq LE.le {p, q, r}).symm
state_before: p q r : ℕ+
H : 1 < sumInv {p, q, r}
S : List ℕ+ := sort (fun x x_1 => x ≤ x_1) {p, q, r}
hS : List.Sorted (fun x x_1 => x ≤ x_1) S
⊢ (∃ q_1 r_1, A' q_1 r_1 = {p, q, r}) ∨
    (∃ r_1, D' r_1 = {p, q, r}) ∨ E' 3 = {p, q, r} ∨ E' 4 = {p, q, r} ∨ E' 5 = {p, q, r}

tactic: rw [hpqr]
state_before: p q r : ℕ+
H : 1 < sumInv {p, q, r}
S : List ℕ+ := sort (fun x x_1 => x ≤ x_1) {p, q, r}
hS : List.Sorted (fun x x_1 => x ≤ x_1) S
hpqr : {p, q, r} = ↑S
⊢ (∃ q_1 r_1, A' q_1 r_1 = {p, q, r}) ∨
    (∃ r_1, D' r_1 = {p, q, r}) ∨ E' 3 = {p, q, r} ∨ E' 4 = {p, q, r} ∨ E' 5 = {p, q, r}

tactic: rw [hpqr] at H
state_before: p q r : ℕ+
H : 1 < sumInv {p, q, r}
S : List ℕ+ := sort (fun x x_1 => x ≤ x_1) {p, q, r}
hS : List.Sorted (fun x x_1 => x ≤ x_1) S
hpqr : {p, q, r} = ↑S
⊢ (∃ q r, A' q r = ↑S) ∨ (∃ r, D' r = ↑S) ∨ E' 3 = ↑S ∨ E' 4 = ↑S ∨ E' 5 = ↑S

tactic: apply admissible_of_one_lt_sumInv_aux hS _ H
state_before: p q r : ℕ+
S : List ℕ+ := sort (fun x x_1 => x ≤ x_1) {p, q, r}
H : 1 < sumInv ↑S
hS : List.Sorted (fun x x_1 => x ≤ x_1) S
hpqr : {p, q, r} = ↑S
⊢ (∃ q r, A' q r = ↑S) ∨ (∃ r, D' r = ↑S) ∨ E' 3 = ↑S ∨ E' 4 = ↑S ∨ E' 5 = ↑S

tactic: simp only [ge_iff_le, insert_eq_cons, length_sort, card_cons, card_singleton]
state_before: p q r : ℕ+
S : List ℕ+ := sort (fun x x_1 => x ≤ x_1) {p, q, r}
H : 1 < sumInv ↑S
hS : List.Sorted (fun x x_1 => x ≤ x_1) S
hpqr : {p, q, r} = ↑S
⊢ List.length S = 3
Theorem: Polynomial.toFinsupp_C_mul_X
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [C_mul_X_eq_monomial, toFinsupp_monomial]
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
⊢ (↑C a * X).toFinsupp = Finsupp.single 1 a
Theorem: Num.ofZNum'_toNat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← PosNum.to_nat_to_int p]
state_before: α : Type ?u.862147
p : PosNum
⊢ castNum <$> ofZNum' (ZNum.pos p) = toNat' ↑p

tactic: rfl
state_before: α : Type ?u.862147
p : PosNum
⊢ castNum <$> ofZNum' (ZNum.pos p) = toNat' ↑↑p

tactic: rw [← succ'_to_nat]
state_before: α : Type ?u.862147
p : PosNum
⊢ ↑(↑(PosNum.pred' p) + 1) = ↑p

tactic: simp
state_before: α : Type ?u.862147
p : PosNum
⊢ ↑↑(succ' (PosNum.pred' p)) = ↑p
Theorem: tsub_le_tsub_add_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, ← add_assoc, add_right_comm]
state_before: α : Type u_1
β : Type ?u.12335
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a - c ≤ a - b + (b - c)

tactic: exact le_add_tsub.trans (add_le_add_right le_add_tsub _)
state_before: α : Type u_1
β : Type ?u.12335
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a ≤ c + (b - c) + (a - b)
Theorem: IsLocalization.mk'_eq_zero_iff
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [← (map_units S s).mul_left_inj, mk'_spec, zero_mul, map_eq_zero_iff M]
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.700135
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
s : { x // x ∈ M }
⊢ mk' S x s = 0 ↔ ∃ m, ↑m * x = 0
Theorem: isLUB_Ico
File: Mathlib/Order/Bounds/Basic.lean

tactic: simpa only [dual_Ioc] using isGLB_Ioc hab.dual
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeInf γ
inst✝ : DenselyOrdered γ
a b : γ
hab : a < b
⊢ IsLUB (Ico a b) b
Theorem: FirstOrder.Language.Substructure.fg_closure
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [hs.coe_toFinset]
state_before: L : Language
M : Type u_1
inst✝ : Structure L M
s : Set M
hs : Set.Finite s
⊢ LowerAdjoint.toFun (closure L) ↑(Finite.toFinset hs) = LowerAdjoint.toFun (closure L) s
Theorem: Matrix.zpow_one_add
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_add h, zpow_one]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit (det A)
i : ℤ
⊢ A ^ (1 + i) = A * A ^ i
Theorem: GaloisConnection.l_ciSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iSup, gc.l_csSup (range_nonempty _) hf, iSup_range']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.99982
ι : Sort u_3
inst✝² : ConditionallyCompleteLattice α
inst✝¹ : ConditionallyCompleteLattice β
inst✝ : Nonempty ι
l : α → β
u : β → α
gc : GaloisConnection l u
f : ι → α
hf : BddAbove (range f)
⊢ l (⨆ (i : ι), f i) = ⨆ (i : ι), l (f i)
Theorem: Path.Homotopy.hcomp_half
File: Mathlib/Topology/Homotopy/Path.lean

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ q₀ : Path x₀ x₁
p₁ q₁ : Path x₁ x₂
F : Homotopy p₀ q₀
G : Homotopy p₁ q₁
t : ↑I
⊢ 0 ≤ 1 / 2

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ q₀ : Path x₀ x₁
p₁ q₁ : Path x₁ x₂
F : Homotopy p₀ q₀
G : Homotopy p₁ q₁
t : ↑I
⊢ 1 / 2 ≤ 1

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ q₀ : Path x₀ x₁
p₁ q₁ : Path x₁ x₂
F : Homotopy p₀ q₀
G : Homotopy p₁ q₁
t : ↑I
⊢ (if ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd ≤ 1 / 2 then
      extend (eval F (t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).fst)
        (2 * ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd)
    else
      extend (eval G (t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).fst)
        (2 * ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd - 1)) =
    x₁
Theorem: Sum.getRight_map
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
f : α → β
g : γ → δ
x : α ⊕ γ
⊢ getRight (Sum.map f g x) = Option.map g (getRight x)