tasksource/leandojo huggingface dataset:
Theorem: IsCoprime.mul_add_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (z * x + y)

tactic: exact h.add_mul_right_right z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + z * x)
Theorem: OrderIso.symm_symm
File: Mathlib/Order/Hom/Basic.lean

tactic: ext
state_before: F : Type ?u.81440
α : Type u_1
β : Type u_2
γ : Type ?u.81449
δ : Type ?u.81452
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
⊢ symm (symm e) = e

tactic: rfl
state_before: case h.h
F : Type ?u.81440
α : Type u_1
β : Type u_2
γ : Type ?u.81449
δ : Type ?u.81452
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
x✝ : α
⊢ ↑(symm (symm e)) x✝ = ↑e x✝
Theorem: LinearPMap.mem_graph
File: Mathlib/LinearAlgebra/LinearPMap.lean

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.480510
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : { x // x ∈ f.domain }
⊢ (↑x, ↑f x) ∈ graph f
Theorem: PartENat.lt_add_iff_pos_right
File: Mathlib/Data/Nat/PartENat.lean

tactic: conv_rhs => rw [← PartENat.add_lt_add_iff_left hx]
state_before: x y : PartENat
hx : x ≠ ⊤
⊢ x < x + y ↔ 0 < y

tactic: rw [add_zero]
state_before: x y : PartENat
hx : x ≠ ⊤
⊢ x < x + y ↔ x + 0 < x + y
Theorem: List.reverse_concat
File: Std/Data/List/Init/Lemmas.lean

tactic: rw [concat_eq_append, reverse_append]
state_before: α : Type u_1
l : List α
a : α
⊢ reverse (concat l a) = a :: reverse l

tactic: rfl
state_before: α : Type u_1
l : List α
a : α
⊢ reverse [a] ++ reverse l = a :: reverse l
Theorem: List.infix_cons_iff
File: Std/Data/List/Lemmas.lean

tactic: constructor
state_before: α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: rintro ⟨⟨hd, tl⟩, t, hl₃⟩
state_before: case mp
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+: a :: l₂ → l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: exact Or.inl ⟨t, hl₃⟩
state_before: case mp.intro.nil.intro
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ t : List α✝
hl₃ : [] ++ l₁ ++ t = a :: l₂
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: simp only [cons_append] at hl₃
state_before: case mp.intro.cons.intro
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ t : List α✝
hl₃ : head✝ :: tail✝ ++ l₁ ++ t = a :: l₂
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: injection hl₃ with _ hl₄
state_before: case mp.intro.cons.intro
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ t : List α✝
hl₃ : head✝ :: (tail✝ ++ l₁ ++ t) = a :: l₂
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: exact Or.inr ⟨_, t, hl₄⟩
state_before: case mp.intro.cons.intro
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ t : List α✝
head_eq✝ : head✝ = a
hl₄ : tail✝ ++ l₁ ++ t = l₂
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

tactic: rintro (h | hl₁)
state_before: case mpr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂ → l₁ <:+: a :: l₂

tactic: exact h.isInfix
state_before: case mpr.inl
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
h : l₁ <+: a :: l₂
⊢ l₁ <:+: a :: l₂

tactic: exact infix_cons hl₁
state_before: case mpr.inr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
hl₁ : l₁ <:+: l₂
⊢ l₁ <:+: a :: l₂
Theorem: isClosedMap_iff_closure_image
File: Mathlib/Topology/Maps.lean

tactic: rw [hc.closure_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.226322
δ : Type ?u.226325
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hs : ∀ (s : Set α), closure (f '' s) ⊆ f '' closure s
c : Set α
hc : IsClosed c
⊢ f '' closure c = f '' c
Theorem: FiniteField.pow_dichotomy
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: have h₁ := FiniteField.pow_card_sub_one_eq_one a ha
state_before: K : Type ?u.1099307
R : Type ?u.1099310
F : Type u_1
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ a ^ (Fintype.card F / 2) = 1 ∨ a ^ (Fintype.card F / 2) = -1

tactic: rw [← Nat.two_mul_odd_div_two (FiniteField.odd_card_of_char_ne_two hF), mul_comm, pow_mul,
  pow_two] at h₁
state_before: K : Type ?u.1099307
R : Type ?u.1099310
F : Type u_1
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
h₁ : a ^ (Fintype.card F - 1) = 1
⊢ a ^ (Fintype.card F / 2) = 1 ∨ a ^ (Fintype.card F / 2) = -1

tactic: exact mul_self_eq_one_iff.mp h₁
state_before: K : Type ?u.1099307
R : Type ?u.1099310
F : Type u_1
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
h₁ : a ^ (Fintype.card F / 2) * a ^ (Fintype.card F / 2) = 1
⊢ a ^ (Fintype.card F / 2) = 1 ∨ a ^ (Fintype.card F / 2) = -1
Theorem: OrderIso.complementedLattice
File: Mathlib/Order/Hom/Basic.lean

tactic: obtain ⟨y, hy⟩ := exists_isCompl (f.symm x)
state_before: F : Type ?u.128418
α : Type u_1
β : Type u_2
γ : Type ?u.128427
δ : Type ?u.128430
inst✝⁴ : Lattice α
inst✝³ : Lattice β
inst✝² : BoundedOrder α
inst✝¹ : BoundedOrder β
f : α ≃o β
inst✝ : ComplementedLattice α
x : β
⊢ ∃ b, IsCompl x b

tactic: rw [← f.symm_apply_apply y] at hy
state_before: case intro
F : Type ?u.128418
α : Type u_1
β : Type u_2
γ : Type ?u.128427
δ : Type ?u.128430
inst✝⁴ : Lattice α
inst✝³ : Lattice β
inst✝² : BoundedOrder α
inst✝¹ : BoundedOrder β
f : α ≃o β
inst✝ : ComplementedLattice α
x : β
y : α
hy : IsCompl (↑(symm f) x) y
⊢ ∃ b, IsCompl x b

tactic: exact ⟨f y, f.symm.isCompl_iff.2 hy⟩
state_before: case intro
F : Type ?u.128418
α : Type u_1
β : Type u_2
γ : Type ?u.128427
δ : Type ?u.128430
inst✝⁴ : Lattice α
inst✝³ : Lattice β
inst✝² : BoundedOrder α
inst✝¹ : BoundedOrder β
f : α ≃o β
inst✝ : ComplementedLattice α
x : β
y : α
hy : IsCompl (↑(symm f) x) (↑(symm f) (↑f y))
⊢ ∃ b, IsCompl x b
Theorem: MeasureTheory.Lp.snorm_exponent_top_lim_le_liminf_snorm_exponent_top
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [snorm_exponent_top_lim_eq_essSup_liminf h_lim]
state_before: α : Type u_2
E : Type ?u.8116013
F : Type u_3
G : Type ?u.8116019
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
ι : Type u_1
inst✝² : Nonempty ι
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → F
f_lim : α → F
h_lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))
⊢ snorm f_lim ⊤ μ ≤ liminf (fun n => snorm (f n) ⊤ μ) atTop

tactic: simp_rw [snorm_exponent_top, snormEssSup]
state_before: α : Type u_2
E : Type ?u.8116013
F : Type u_3
G : Type ?u.8116019
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
ι : Type u_1
inst✝² : Nonempty ι
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → F
f_lim : α → F
h_lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))
⊢ essSup (fun x => liminf (fun m => ↑‖f m x‖₊) atTop) μ ≤ liminf (fun n => snorm (f n) ⊤ μ) atTop

tactic: exact ENNReal.essSup_liminf_le fun n => fun x => (‖f n x‖₊ : ℝ≥0∞)
state_before: α : Type u_2
E : Type ?u.8116013
F : Type u_3
G : Type ?u.8116019
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
ι : Type u_1
inst✝² : Nonempty ι
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → F
f_lim : α → F
h_lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))
⊢ essSup (fun x => liminf (fun m => ↑‖f m x‖₊) atTop) μ ≤ liminf (fun n => essSup (fun x => ↑‖f n x‖₊) μ) atTop
Theorem: inf_himp_le
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [inf_comm, ← le_himp_iff]
state_before: ι : Type ?u.28059
α : Type u_1
β : Type ?u.28065
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⊓ (a ⇨ b) ≤ b
Theorem: Associates.count_mul_of_coprime
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: by_cases ha : a = 0
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
⊢ count p (factors a) = 0 ∨ count p (factors a) = count p (factors (a * b))

tactic: cases' count_of_coprime ha hb hab hp with hz hb0
state_before: case neg
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
ha : ¬a = 0
⊢ count p (factors a) = 0 ∨ count p (factors a) = count p (factors (a * b))

tactic: apply Or.intro_right
state_before: case neg.inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
ha : ¬a = 0
hb0 : count p (factors b) = 0
⊢ count p (factors a) = 0 ∨ count p (factors a) = count p (factors (a * b))

tactic: rw [count_mul ha hb hp, hb0, add_zero]
state_before: case neg.inr.h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
ha : ¬a = 0
hb0 : count p (factors b) = 0
⊢ count p (factors a) = count p (factors (a * b))

tactic: simp [ha]
state_before: case pos
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
ha : a = 0
⊢ count p (factors a) = 0 ∨ count p (factors a) = count p (factors (a * b))

tactic: tauto
state_before: case neg.inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
hab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d
ha : ¬a = 0
hz : count p (factors a) = 0
⊢ count p (factors a) = 0 ∨ count p (factors a) = count p (factors (a * b))
Theorem: Polynomial.degree_erase_lt
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: apply lt_of_le_of_ne (degree_erase_le _ _)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.561231
hp : p ≠ 0
⊢ degree (erase (natDegree p) p) < degree p

tactic: rw [degree_eq_natDegree hp, degree, support_erase]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.561231
hp : p ≠ 0
⊢ degree (erase (natDegree p) p) ≠ degree p

tactic: exact fun h => not_mem_erase _ _ (mem_of_max h)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.561231
hp : p ≠ 0
⊢ Finset.max (Finset.erase (support p) (natDegree p)) ≠ ↑(natDegree p)
Theorem: Submonoid.mem_map
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: rw [← bex_def]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.13819
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_3
mc : MonoidHomClass F M N
f : F
S : Submonoid M
y : N
⊢ y ∈ map f S ↔ ∃ x, x ∈ S ∧ ↑f x = y

tactic: exact mem_image_iff_bex
state_before: M : Type u_1
N : Type u_2
P : Type ?u.13819
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_3
mc : MonoidHomClass F M N
f : F
S : Submonoid M
y : N
⊢ y ∈ map f S ↔ ∃ x x_1, ↑f x = y
Theorem: Finset.fold_union_inter
File: Mathlib/Data/Finset/Fold.lean

tactic: unfold fold
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17454
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (fold op b₁ f (s₁ ∪ s₂)) (fold op b₂ f (s₁ ∩ s₂)) = op (fold op b₂ f s₁) (fold op b₁ f s₂)

tactic: rw [← fold_add op, ← Multiset.map_add, union_val, inter_val, union_add_inter, Multiset.map_add,
  hc.comm, fold_add]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17454
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (Multiset.fold op b₁ (Multiset.map f (s₁ ∪ s₂).val)) (Multiset.fold op b₂ (Multiset.map f (s₁ ∩ s₂).val)) =
    op (Multiset.fold op b₂ (Multiset.map f s₁.val)) (Multiset.fold op b₁ (Multiset.map f s₂.val))
Theorem: continuous_of_cover_nhds
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [ContinuousAt, ← nhdsWithin_eq_nhds.2 hi]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.317635
δ : Type ?u.317638
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
ι : Sort u_1
f : α → β
s : ι → Set α
hs : ∀ (x : α), ∃ i, s i ∈ 𝓝 x
hf : ∀ (i : ι), ContinuousOn f (s i)
x : α
i : ι
hi : s i ∈ 𝓝 x
⊢ ContinuousAt f x

tactic: exact hf _ _ (mem_of_mem_nhds hi)
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.317635
δ : Type ?u.317638
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
ι : Sort u_1
f : α → β
s : ι → Set α
hs : ∀ (x : α), ∃ i, s i ∈ 𝓝 x
hf : ∀ (i : ι), ContinuousOn f (s i)
x : α
i : ι
hi : s i ∈ 𝓝 x
⊢ Tendsto f (𝓝[s i] x) (𝓝 (f x))
Theorem: Equiv.Perm.prod_list_swap_mem_alternatingGroup_iff_even_length
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

tactic: rw [mem_alternatingGroup, sign_prod_list_swap hl, ← Units.val_eq_one, Units.val_pow_eq_pow_val,
  Units.coe_neg_one, neg_one_pow_eq_one_iff_even]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
l : List (Perm α)
hl : ∀ (g : Perm α), g ∈ l → IsSwap g
⊢ List.prod l ∈ alternatingGroup α ↔ Even (List.length l)

tactic: decide
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
l : List (Perm α)
hl : ∀ (g : Perm α), g ∈ l → IsSwap g
⊢ -1 ≠ 1
Theorem: PiNat.res_injective
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: intro x y h
state_before: E : ℕ → Type ?u.22017
α : Type u_1
⊢ Injective res

tactic: ext n
state_before: E : ℕ → Type ?u.22017
α : Type u_1
x y : ℕ → α
h : res x = res y
⊢ x = y

tactic: apply res_eq_res.mp _ (Nat.lt_succ_self _)
state_before: case h
E : ℕ → Type ?u.22017
α : Type u_1
x y : ℕ → α
h : res x = res y
n : ℕ
⊢ x n = y n

tactic: rw [h]
state_before: E : ℕ → Type ?u.22017
α : Type u_1
x y : ℕ → α
h : res x = res y
n : ℕ
⊢ res x (Nat.succ n) = res (fun n => y n) (Nat.succ n)
Theorem: Finset.noncommProd_insert_of_not_mem
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: convert noncommProd_lemma _ f comm using 3
state_before: F : Type ?u.142925
ι : Type ?u.142928
α : Type u_1
β : Type u_2
γ : Type ?u.142937
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
⊢ Set.Pairwise {x | x ∈ f a ::ₘ Multiset.map f s.val} Commute

tactic: simp [@eq_comm _ (f a)]
state_before: case h.e'_2.h.e'_2.h.a
F : Type ?u.142925
ι : Type ?u.142928
α : Type u_1
β : Type u_2
γ : Type ?u.142937
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
x✝ : β
⊢ x✝ ∈ f a ::ₘ Multiset.map f s.val ↔ x✝ ∈ Multiset.map f (insert a s).val

tactic: rw [Multiset.noncommProd_cons, noncommProd]
state_before: F : Type ?u.142925
ι : Type ?u.142928
α : Type u_1
β : Type u_2
γ : Type ?u.142937
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
⊢ Multiset.noncommProd (f a ::ₘ Multiset.map f s.val)
      (_ : Set.Pairwise {x | x ∈ f a ::ₘ Multiset.map f s.val} Commute) =
    f a * noncommProd s f (_ : Set.Pairwise ↑s fun a b => Commute (f a) (f b))
Theorem: Function.Periodic.sub_const
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg] using h.add_const (-a)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.88614
f g : α → β
c c₁ c₂ x : α
inst✝ : AddCommGroup α
h : Periodic f c
a : α
⊢ Periodic (fun x => f (x - a)) c
Theorem: FreeProduct.NeWord.toList_ne_nil
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: induction w
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.485949
inst✝ : Monoid N
i j : ι
w : NeWord M i j
⊢ toList w ≠ []

tactic: rintro ⟨rfl⟩
state_before: case singleton
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.485949
inst✝ : Monoid N
i j i✝ : ι
x✝ : M i✝
a✝ : x✝ ≠ 1
⊢ toList (singleton x✝ a✝) ≠ []

tactic: apply List.append_ne_nil_of_ne_nil_left
state_before: case append
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.485949
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : toList _w₁✝ ≠ []
_w₂_ih✝ : toList _w₂✝ ≠ []
⊢ toList (append _w₁✝ _hne✝ _w₂✝) ≠ []

tactic: assumption
state_before: case append.a
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.485949
inst✝ : Monoid N
i j i✝ j✝ k✝ l✝ : ι
_w₁✝ : NeWord M i✝ j✝
_hne✝ : j✝ ≠ k✝
_w₂✝ : NeWord M k✝ l✝
_w₁_ih✝ : toList _w₁✝ ≠ []
_w₂_ih✝ : toList _w₂✝ ≠ []
⊢ toList _w₁✝ ≠ []
Theorem: Nat.ModEq.mul_right_cancel'
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [modEq_iff_dvd, ← sub_mul, mul_dvd_mul_iff_right (by simp [hc] : (c : ℤ) ≠ 0)]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m]

tactic: simp [hc]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ ↑c ≠ 0
Theorem: Algebra.sInf_toSubmodule
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Set (Subalgebra R A)
⊢ ↑(↑Subalgebra.toSubmodule (sInf S)) = ↑(sInf (↑Subalgebra.toSubmodule '' S))
Theorem: rank_span_set
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [← @setOf_mem_eq _ s, ← Subtype.range_coe_subtype]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.420675
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
hs : LinearIndependent R fun x => ↑x
⊢ Module.rank R { x // x ∈ span R s } = (#↑s)

tactic: exact rank_span hs
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.420675
R : Type u
inst✝³ : Ring R
inst✝² : StrongRankCondition R
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
hs : LinearIndependent R fun x => ↑x
⊢ Module.rank R { x // x ∈ span R (range Subtype.val) } = (#↑(range Subtype.val))
Theorem: Real.volume_Iic
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rw [← measure_congr Iio_ae_eq_Iic]
state_before: ι : Type ?u.252971
inst✝ : Fintype ι
a : ℝ
⊢ ↑↑volume (Iic a) = ⊤

tactic: simp
state_before: ι : Type ?u.252971
inst✝ : Fintype ι
a : ℝ
⊢ ↑↑volume (Iio a) = ⊤
Theorem: ADEInequality.lt_six
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: have h6 : (0 : ℚ) < 6 := by norm_num
state_before: r : ℕ+
H : 1 < sumInv {2, 3, r}
⊢ r < 6

tactic: contrapose! H
state_before: r : ℕ+
H : 1 < sumInv {2, 3, r}
h6 : 0 < 6
⊢ r < 6

tactic: rw [sumInv_pqr]
state_before: r : ℕ+
h6 : 0 < 6
H : ¬r < 6
⊢ sumInv {2, 3, r} ≤ 1

tactic: simp at H
state_before: r : ℕ+
h6 : 0 < 6
H : ¬r < 6
⊢ (↑↑2)⁻¹ + (↑↑3)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: have hr: (r : ℚ)⁻¹ ≤ 6⁻¹ := by
  rw [inv_le_inv _ h6]
  assumption_mod_cast
  norm_num
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
⊢ (↑↑2)⁻¹ + (↑↑3)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: calc
  (2⁻¹ + 3⁻¹ + (r : ℚ)⁻¹ : ℚ) ≤ 2⁻¹ + 3⁻¹ + 6⁻¹ := add_le_add (add_le_add le_rfl le_rfl) hr
  _ = 1 := by norm_num
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
hr : (↑↑r)⁻¹ ≤ 6⁻¹
⊢ (↑↑2)⁻¹ + (↑↑3)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: norm_num
state_before: r : ℕ+
H : 1 < sumInv {2, 3, r}
⊢ 0 < 6

tactic: rw [inv_le_inv _ h6]
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
⊢ (↑↑r)⁻¹ ≤ 6⁻¹

tactic: assumption_mod_cast
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
⊢ 6 ≤ ↑↑r

r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
⊢ 0 < ↑↑r

tactic: norm_num
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
⊢ 0 < ↑↑r

tactic: norm_num
state_before: r : ℕ+
h6 : 0 < 6
H : 6 ≤ r
hr : (↑↑r)⁻¹ ≤ 6⁻¹
⊢ 2⁻¹ + 3⁻¹ + 6⁻¹ = 1
Theorem: MeasureTheory.snorm_smul_measure_of_ne_top
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases hp0 : p = 0
state_before: α : Type u_1
E : Type ?u.2224619
F : Type u_2
G : Type ?u.2224625
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ snorm f p (c • μ) = c ^ ENNReal.toReal (1 / p) • snorm f p μ

tactic: simp [hp0]
state_before: case pos
α : Type u_1
E : Type ?u.2224619
F : Type u_2
G : Type ?u.2224625
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
hp0 : p = 0
⊢ snorm f p (c • μ) = c ^ ENNReal.toReal (1 / p) • snorm f p μ

tactic: exact snorm_smul_measure_of_ne_zero_of_ne_top hp0 hp_ne_top c
state_before: case neg
α : Type u_1
E : Type ?u.2224619
F : Type u_2
G : Type ?u.2224625
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
hp0 : ¬p = 0
⊢ snorm f p (c • μ) = c ^ ENNReal.toReal (1 / p) • snorm f p μ
Theorem: Subgroup.relindex_inf_le
File: Mathlib/GroupTheory/Index.lean

tactic: by_cases h : H.relindex L = 0
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ relindex (H ⊓ K) L ≤ relindex H L * relindex K L

tactic: rw [← inf_relindex_right, inf_assoc, ← relindex_mul_relindex _ _ L inf_le_right inf_le_right,
  inf_relindex_right, inf_relindex_right]
state_before: case neg
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : ¬relindex H L = 0
⊢ relindex (H ⊓ K) L ≤ relindex H L * relindex K L

tactic: exact mul_le_mul_right' (relindex_le_of_le_right inf_le_right h) (K.relindex L)
state_before: case neg
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : ¬relindex H L = 0
⊢ relindex H (K ⊓ L) * relindex K L ≤ relindex H L * relindex K L

tactic: exact (le_of_eq (relindex_eq_zero_of_le_left inf_le_left h)).trans (zero_le _)
state_before: case pos
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : relindex H L = 0
⊢ relindex (H ⊓ K) L ≤ relindex H L * relindex K L