tasksource/leandojo huggingface dataset:
Theorem: Polynomial.content_eq_zero_iff
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [content, Finset.gcd_eq_zero_iff]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ content p = 0 ↔ p = 0

tactic: constructor <;> intro h
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ (∀ (x : ℕ), x ∈ support p → coeff p x = 0) ↔ p = 0

tactic: ext n
state_before: case mp
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
⊢ p = 0

tactic: by_cases h0 : n ∈ p.support
state_before: case mp.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
n : ℕ
⊢ coeff p n = coeff 0 n

tactic: rw [h n h0, coeff_zero]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
n : ℕ
h0 : n ∈ support p
⊢ coeff p n = coeff 0 n

tactic: rw [mem_support_iff] at h0
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
n : ℕ
h0 : ¬n ∈ support p
⊢ coeff p n = coeff 0 n

tactic: push_neg  at h0
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
n : ℕ
h0 : ¬coeff p n ≠ 0
⊢ coeff p n = coeff 0 n

tactic: simp [h0]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ∀ (x : ℕ), x ∈ support p → coeff p x = 0
n : ℕ
h0 : coeff p n = 0
⊢ coeff p n = coeff 0 n

tactic: intro x
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : p = 0
⊢ ∀ (x : ℕ), x ∈ support p → coeff p x = 0

tactic: simp [h]
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : p = 0
x : ℕ
⊢ x ∈ support p → coeff p x = 0
Theorem: AlgEquiv.ofLinearEquiv_toLinearEquiv
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_mul✝ : ∀ (x y : A₁), ↑l (x * y) = ↑l x * ↑l y
commutes✝ : ∀ (r : R), ↑l (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
map_mul : ∀ (x y : A₁), ↑(toLinearEquiv e) (x * y) = ↑(toLinearEquiv e) x * ↑(toLinearEquiv e) y
commutes : ∀ (r : R), ↑(toLinearEquiv e) (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
⊢ ofLinearEquiv (toLinearEquiv e) map_mul commutes = e

tactic: rfl
state_before: case h
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
l : A₁ ≃ₗ[R] A₂
map_mul✝ : ∀ (x y : A₁), ↑l (x * y) = ↑l x * ↑l y
commutes✝ : ∀ (r : R), ↑l (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
map_mul : ∀ (x y : A₁), ↑(toLinearEquiv e) (x * y) = ↑(toLinearEquiv e) x * ↑(toLinearEquiv e) y
commutes : ∀ (r : R), ↑(toLinearEquiv e) (↑(algebraMap R A₁) r) = ↑(algebraMap R A₂) r
a✝ : A₁
⊢ ↑(ofLinearEquiv (toLinearEquiv e) map_mul commutes) a✝ = ↑e a✝
Theorem: Substring.Valid.next_stop
File: Std/Data/String/Lemmas.lean

tactic: simp [h.bsize, h.next_stop]
state_before: x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.next x✝ { byteIdx := Substring.bsize x✝ } = { byteIdx := Substring.bsize x✝ }
Theorem: List.lookupAll_length_le_one
File: Mathlib/Data/List/Sigma.lean

tactic: have := Nodup.sublist ((lookupAll_sublist a l).map _) h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
⊢ length (lookupAll a l) ≤ 1

tactic: rw [map_map] at this
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
this : Nodup (map Sigma.fst (map (Sigma.mk a) (lookupAll a l)))
⊢ length (lookupAll a l) ≤ 1

tactic: rwa [← nodup_replicate, ← map_const]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
this : Nodup (map (Sigma.fst ∘ Sigma.mk a) (lookupAll a l))
⊢ length (lookupAll a l) ≤ 1
Theorem: Path.delayReflLeft_one
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: simp only [delayReflLeft, delayReflRight_one, Path.symm_symm]
state_before: X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflLeft 1 γ = γ
Theorem: Set.toFinset_off_diag
File: Mathlib/Data/Fintype/Prod.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.994
γ : Type ?u.997
s✝ t s : Set α
inst✝² : DecidableEq α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑(offDiag s)
⊢ ∀ (a : α × α), a ∈ toFinset (offDiag s) ↔ a ∈ Finset.offDiag (toFinset s)
Theorem: Nat.SOM.Poly.append_denote
File: src/lean/Init/Data/Nat/SOM.lean

tactic: match p₁ with
| [] => simp!
| v :: p₁ => simp! [append_denote _ p₁ p₂, Nat.add_assoc]
state_before: ctx : Context
p₁ p₂ : Poly
⊢ denote ctx (p₁ ++ p₂) = denote ctx p₁ + denote ctx p₂

tactic: simp!
state_before: ctx : Context
p₁ p₂ : Poly
⊢ denote ctx ([] ++ p₂) = denote ctx [] + denote ctx p₂

tactic: simp! [append_denote _ p₁ p₂, Nat.add_assoc]
state_before: ctx : Context
p₁✝ p₂ : Poly
v : Nat × Mon
p₁ : List (Nat × Mon)
⊢ denote ctx (v :: p₁ ++ p₂) = denote ctx (v :: p₁) + denote ctx p₂
Theorem: Associated.pow_pow
File: Mathlib/Algebra/Associated.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type ?u.188347
γ : Type ?u.188350
δ : Type ?u.188353
inst✝ : CommMonoid α
a b : α
n : ℕ
h : a ~ᵤ b
⊢ a ^ n ~ᵤ b ^ n

tactic: convert h.mul_mul ih <;> rw [pow_succ]
state_before: case succ
α : Type u_1
β : Type ?u.188347
γ : Type ?u.188350
δ : Type ?u.188353
inst✝ : CommMonoid α
a b : α
h : a ~ᵤ b
n : ℕ
ih : a ^ n ~ᵤ b ^ n
⊢ a ^ Nat.succ n ~ᵤ b ^ Nat.succ n

tactic: simp [h]
state_before: case zero
α : Type u_1
β : Type ?u.188347
γ : Type ?u.188350
δ : Type ?u.188353
inst✝ : CommMonoid α
a b : α
h : a ~ᵤ b
⊢ a ^ Nat.zero ~ᵤ b ^ Nat.zero

tactic: rfl
state_before: case zero
α : Type u_1
β : Type ?u.188347
γ : Type ?u.188350
δ : Type ?u.188353
inst✝ : CommMonoid α
a b : α
h : a ~ᵤ b
⊢ 1 ~ᵤ 1
Theorem: Set.Finite.exists_lt_map_eq_of_forall_mem
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← maps_univ_to] at hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : LinearOrder α
inst✝ : Infinite α
t : Set β
f : α → β
hf : ∀ (a : α), f a ∈ t
ht : Set.Finite t
⊢ ∃ a b, a < b ∧ f a = f b

tactic: obtain ⟨a, -, b, -, h⟩ := infinite_univ.exists_lt_map_eq_of_mapsTo hf ht
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : LinearOrder α
inst✝ : Infinite α
t : Set β
f : α → β
hf : MapsTo (fun a => f a) univ t
ht : Set.Finite t
⊢ ∃ a b, a < b ∧ f a = f b

tactic: exact ⟨a, b, h⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : LinearOrder α
inst✝ : Infinite α
t : Set β
f : α → β
hf : MapsTo (fun a => f a) univ t
ht : Set.Finite t
a b : α
h : a < b ∧ f a = f b
⊢ ∃ a b, a < b ∧ f a = f b
Theorem: List.map_ret_sublist_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: induction' l using reverseRecOn with l a ih <;>
simp only [map, map_append, sublists_concat]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map List.ret l <+ sublists l

tactic: exact ((append_sublist_append_left _).2 <|
            singleton_sublist.2 <| mem_map.2 ⟨[], mem_sublists.2 (nil_sublist _), by rfl⟩).trans
        ((append_sublist_append_right _).2 ih)
state_before: case H1
α : Type u
β : Type v
γ : Type w
l : List α
a : α
ih : map List.ret l <+ sublists l
⊢ map List.ret l ++ [List.ret a] <+ sublists l ++ map (fun x => x ++ [a]) (sublists l)

tactic: simp only [sublists_nil, sublist_cons]
state_before: case H0
α : Type u
β : Type v
γ : Type w
⊢ [] <+ sublists []

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
l : List α
a : α
ih : map List.ret l <+ sublists l
⊢ [] ++ [a] = List.ret a
Theorem: Part.some_append_some
File: Mathlib/Data/Part.lean

tactic: simp [append_def]
state_before: α : Type u_1
β : Type ?u.81115
γ : Type ?u.81118
inst✝ : Append α
a b : α
⊢ some a ++ some b = some (a ++ b)
Theorem: CategoryTheory.IsPushout.IsVanKampen.flip
File: Mathlib/CategoryTheory/Adhesive.lean

tactic: introv W' hf hg hh hi w
state_before: J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
H : IsPushout f g h i
H' : IsVanKampen H
⊢ IsVanKampen (_ : IsPushout g f i h)

tactic: simpa only [IsPushout.flip_iff, IsPullback.flip_iff, and_comm] using
  H' g' f' i' h' αW αY αX αZ hg hf hi hh w.flip
state_before: J : Type v'
inst✝¹ : Category J
C : Type u
inst✝ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
H : IsPushout f g h i
H' : IsVanKampen H
W' X' Y' Z' : C
f' : W' ⟶ X'
g' : W' ⟶ Y'
h' : X' ⟶ Z'
i' : Y' ⟶ Z'
αW : W' ⟶ W
αX : X' ⟶ Y
αY : Y' ⟶ X
αZ : Z' ⟶ Z
hf : IsPullback f' αW αX g
hg : IsPullback g' αW αY f
hh : CommSq h' αX αZ i
hi : CommSq i' αY αZ h
w : CommSq f' g' h' i'
⊢ IsPushout f' g' h' i' ↔ IsPullback h' αX αZ i ∧ IsPullback i' αY αZ h
Theorem: Nat.Prime.multiplicity_factorial
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: simp [Ico, hp.multiplicity_one]
state_before: p : ℕ
hp : Prime p
b : ℕ
x✝ : log p 0 < b
⊢ multiplicity p 0! = ↑(∑ i in Ico 1 b, 0 / p ^ i)

tactic: rw [factorial_succ, hp.multiplicity_mul, add_comm]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ multiplicity p (n + 1)! = multiplicity p n ! + multiplicity p (n + 1)

tactic: rw [multiplicity_factorial hp ((log_mono_right <| le_succ _).trans_lt hb), ←
  multiplicity_eq_card_pow_dvd hp.ne_one (succ_pos _) hb]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ multiplicity p n ! + multiplicity p (n + 1) =
    ↑(∑ i in Ico 1 b, n / p ^ i) + ↑(card (filter (fun i => p ^ i ∣ n + 1) (Ico 1 b)))

tactic: rw [sum_add_distrib, sum_boole]
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ ↑(∑ i in Ico 1 b, n / p ^ i) + ↑(card (filter (fun i => p ^ i ∣ n + 1) (Ico 1 b))) =
    ↑(∑ i in Ico 1 b, (n / p ^ i + if p ^ i ∣ n + 1 then 1 else 0))

tactic: simp
state_before: p : ℕ
hp : Prime p
n b : ℕ
hb : log p (n + 1) < b
⊢ ↑(∑ i in Ico 1 b, n / p ^ i) + ↑(card (filter (fun i => p ^ i ∣ n + 1) (Ico 1 b))) =
    ↑(∑ x in Ico 1 b, n / p ^ x + ↑(card (filter (fun x => p ^ x ∣ n + 1) (Ico 1 b))))
Theorem: RatFunc.num_denom_mul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: conv_lhs =>
  rw [← num_div_denom x, ← num_div_denom y, div_mul_div_comm, ← RingHom.map_mul, ←
    RingHom.map_mul]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = ↑(algebraMap K[X] (RatFunc K)) (num x * num y) / ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)
Theorem: lt_of_mul_self_lt_mul_self
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simp_rw [← sq]
state_before: β : Type ?u.245753
A : Type ?u.245756
G : Type ?u.245759
M : Type ?u.245762
R : Type u_1
inst✝ : LinearOrderedSemiring R
a b : R
hb : 0 ≤ b
⊢ a * a < b * b → a < b

tactic: exact lt_of_pow_lt_pow _ hb
state_before: β : Type ?u.245753
A : Type ?u.245756
G : Type ?u.245759
M : Type ?u.245762
R : Type u_1
inst✝ : LinearOrderedSemiring R
a b : R
hb : 0 ≤ b
⊢ a ^ 2 < b ^ 2 → a < b
Theorem: CategoryTheory.Functor.hasStrongEpiMonoFactorisations_imp_of_isEquivalence
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: let em : StrongEpiMonoFactorisation (F.inv.map f) :=
  (HasStrongEpiMonoFactorisations.has_fac (F.inv.map f)).some
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
h : HasStrongEpiMonoFactorisations C
X Y : D
f : X ⟶ Y
⊢ Nonempty (StrongEpiMonoFactorisation f)

tactic: haveI : Mono (F.map em.m ≫ F.asEquivalence.counitIso.hom.app Y) := mono_comp _ _
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
h : HasStrongEpiMonoFactorisations C
X Y : D
f : X ⟶ Y
em : StrongEpiMonoFactorisation ((inv F).map f) :=
  Nonempty.some (_ : Nonempty (StrongEpiMonoFactorisation ((inv F).map f)))
⊢ Nonempty (StrongEpiMonoFactorisation f)

tactic: haveI : StrongEpi (F.asEquivalence.counitIso.inv.app X ≫ F.map em.e) := strongEpi_comp _ _
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
h : HasStrongEpiMonoFactorisations C
X Y : D
f : X ⟶ Y
em : StrongEpiMonoFactorisation ((inv F).map f) :=
  Nonempty.some (_ : Nonempty (StrongEpiMonoFactorisation ((inv F).map f)))
this : Mono (F.map em.m ≫ (asEquivalence F).counitIso.hom.app Y)
⊢ Nonempty (StrongEpiMonoFactorisation f)

tactic: exact
  Nonempty.intro
    { I := F.obj em.I
      e := F.asEquivalence.counitIso.inv.app X ≫ F.map em.e
      m := F.map em.m ≫ F.asEquivalence.counitIso.hom.app Y
      fac := by
        simpa only [Category.assoc, ← F.map_comp_assoc, em.fac, IsEquivalence.fun_inv_map,
          Iso.inv_hom_id_app, Iso.inv_hom_id_app_assoc] using Category.comp_id _ }
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
h : HasStrongEpiMonoFactorisations C
X Y : D
f : X ⟶ Y
em : StrongEpiMonoFactorisation ((inv F).map f) :=
  Nonempty.some (_ : Nonempty (StrongEpiMonoFactorisation ((inv F).map f)))
this✝ : Mono (F.map em.m ≫ (asEquivalence F).counitIso.hom.app Y)
this : StrongEpi ((asEquivalence F).counitIso.inv.app X ≫ F.map em.e)
⊢ Nonempty (StrongEpiMonoFactorisation f)

tactic: simpa only [Category.assoc, ← F.map_comp_assoc, em.fac, IsEquivalence.fun_inv_map,
  Iso.inv_hom_id_app, Iso.inv_hom_id_app_assoc] using Category.comp_id _
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
inst✝ : IsEquivalence F
h : HasStrongEpiMonoFactorisations C
X Y : D
f : X ⟶ Y
em : StrongEpiMonoFactorisation ((inv F).map f) :=
  Nonempty.some (_ : Nonempty (StrongEpiMonoFactorisation ((inv F).map f)))
this✝ : Mono (F.map em.m ≫ (asEquivalence F).counitIso.hom.app Y)
this : StrongEpi ((asEquivalence F).counitIso.inv.app X ≫ F.map em.e)
⊢ ((asEquivalence F).counitIso.inv.app X ≫ F.map em.e) ≫ F.map em.m ≫ (asEquivalence F).counitIso.hom.app Y = f
Theorem: Fintype.two_lt_card_iff
File: Mathlib/Data/Fintype/Card.lean

tactic: simp_rw [← Finset.card_univ, two_lt_card_iff, mem_univ, true_and_iff]
state_before: α : Type u_1
β : Type ?u.24655
γ : Type ?u.24658
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ 2 < card α ↔ ∃ a b c, a ≠ b ∧ a ≠ c ∧ b ≠ c
Theorem: IsOpenMap.of_sections
File: Mathlib/Topology/Maps.lean

tactic: rw [map_map, hgf.comp_eq_id, map_id]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.141298
δ : Type ?u.141301
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f✝ f : α → β
h : ∀ (x : α), ∃ g, ContinuousAt g (f x) ∧ g (f x) = x ∧ Function.RightInverse g f
x : α
g : β → α
hgc : ContinuousAt g (f x)
hgx : g (f x) = x
hgf : Function.RightInverse g f
⊢ 𝓝 (f x) = map f (map g (𝓝 (f x)))

tactic: rw [hgx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.141298
δ : Type ?u.141301
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f✝ f : α → β
h : ∀ (x : α), ∃ g, ContinuousAt g (f x) ∧ g (f x) = x ∧ Function.RightInverse g f
x : α
g : β → α
hgc : ContinuousAt g (f x)
hgx : g (f x) = x
hgf : Function.RightInverse g f
⊢ map f (𝓝 (g (f x))) = map f (𝓝 x)
Theorem: Nat.ArithmeticFunction.IsMultiplicative.iff_ne_zero
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: refine' and_congr_right' (forall₂_congr fun m n => ⟨fun h _ _ => h, fun h hmn => _⟩)
state_before: R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
⊢ IsMultiplicative f ↔ ↑f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → coprime m n → ↑f (m * n) = ↑f m * ↑f n

tactic: rcases eq_or_ne m 0 with (rfl | hm)
state_before: R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → coprime m n → ↑f (m * n) = ↑f m * ↑f n
hmn : coprime m n
⊢ ↑f (m * n) = ↑f m * ↑f n

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → coprime m n → ↑f (m * n) = ↑f m * ↑f n
hmn : coprime m n
hm : m ≠ 0
⊢ ↑f (m * n) = ↑f m * ↑f n

tactic: exact h hm hn hmn
state_before: case inr.inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → coprime m n → ↑f (m * n) = ↑f m * ↑f n
hmn : coprime m n
hm : m ≠ 0
hn : n ≠ 0
⊢ ↑f (m * n) = ↑f m * ↑f n

tactic: simp
state_before: case inl
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
n : ℕ
h : 0 ≠ 0 → n ≠ 0 → coprime 0 n → ↑f (0 * n) = ↑f 0 * ↑f n
hmn : coprime 0 n
⊢ ↑f (0 * n) = ↑f 0 * ↑f n

tactic: simp
state_before: case inr.inl
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m : ℕ
hm : m ≠ 0
h : m ≠ 0 → 0 ≠ 0 → coprime m 0 → ↑f (m * 0) = ↑f m * ↑f 0
hmn : coprime m 0
⊢ ↑f (m * 0) = ↑f m * ↑f 0
Theorem: Filter.HasBasis.uniformEquicontinuous_iff_right
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [uniformEquicontinuous_iff_uniformContinuous, UniformContinuous,
  (UniformFun.hasBasis_uniformity_of_basis ι α hα).tendsto_right_iff]
state_before: ι : Type u_3
κ✝ : Type ?u.126986
X : Type ?u.126989
Y : Type ?u.126992
Z : Type ?u.126995
α : Type u_2
β : Type u_4
γ : Type ?u.127004
𝓕 : Type ?u.127007
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (α × α)
F : ι → β → α
hα : HasBasis (𝓤 α) p s
⊢ UniformEquicontinuous F ↔ ∀ (k : κ), p k → ∀ᶠ (xy : β × β) in 𝓤 β, ∀ (i : ι), (F i xy.fst, F i xy.snd) ∈ s k

tactic: rfl
state_before: ι : Type u_3
κ✝ : Type ?u.126986
X : Type ?u.126989
Y : Type ?u.126992
Z : Type ?u.126995
α : Type u_2
β : Type u_4
γ : Type ?u.127004
𝓕 : Type ?u.127007
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (α × α)
F : ι → β → α
hα : HasBasis (𝓤 α) p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : β × β) in 𝓤 β,
          ((↑UniformFun.ofFun ∘ Function.swap F) x.fst, (↑UniformFun.ofFun ∘ Function.swap F) x.snd) ∈
            (UniformFun.gen ι α ∘ s) i) ↔
    ∀ (k : κ), p k → ∀ᶠ (xy : β × β) in 𝓤 β, ∀ (i : ι), (F i xy.fst, F i xy.snd) ∈ s k
Theorem: List.getD_eq_default
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH generalizing n
state_before: ι : Type ?u.502171
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
hn : length l ≤ n
⊢ getD l n d = d

tactic: exact getD_nil _ _
state_before: case nil
ι : Type ?u.502171
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ : ℕ
hn✝ : length l ≤ n✝
n : ℕ
hn : length [] ≤ n
⊢ getD [] n d = d

tactic: cases n
state_before: case cons
ι : Type ?u.502171
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ : ℕ
hn✝ : length l ≤ n✝
hd : α
tl : List α
IH : ∀ {n : ℕ}, length tl ≤ n → getD tl n d = d
n : ℕ
hn : length (hd :: tl) ≤ n
⊢ getD (hd :: tl) n d = d

tactic: refine' absurd (Nat.zero_lt_succ _) (not_lt_of_ge hn)
state_before: case cons.zero
ι : Type ?u.502171
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
hn✝ : length l ≤ n
hd : α
tl : List α
IH : ∀ {n : ℕ}, length tl ≤ n → getD tl n d = d
hn : length (hd :: tl) ≤ zero
⊢ getD (hd :: tl) zero d = d

tactic: exact IH (Nat.le_of_succ_le_succ hn)
state_before: case cons.succ
ι : Type ?u.502171
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n : ℕ
hn✝ : length l ≤ n
hd : α
tl : List α
IH : ∀ {n : ℕ}, length tl ≤ n → getD tl n d = d
n✝ : ℕ
hn : length (hd :: tl) ≤ succ n✝
⊢ getD (hd :: tl) (succ n✝) d = d
Theorem: Ideal.IsIntegralClosure.eq_bot_of_comap_eq_bot
File: Mathlib/RingTheory/Ideal/Over.lean

tactic: contrapose
state_before: R : Type u_1
inst✝⁹ : CommRing R
S : Type ?u.516571
inst✝⁸ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝⁷ : Algebra R S
A : Type u_2
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra A S
inst✝³ : IsScalarTower R A S
inst✝² : IsIntegralClosure A R S
inst✝¹ : IsDomain A
inst✝ : Nontrivial R
I : Ideal A
⊢ comap (algebraMap R A) I = ⊥ → I = ⊥

tactic: exact (IsIntegralClosure.comap_ne_bot S)
state_before: R : Type u_1
inst✝⁹ : CommRing R
S : Type ?u.516571
inst✝⁸ : CommRing S
f : R →+* S
I✝ J : Ideal S
inst✝⁷ : Algebra R S
A : Type u_2
inst✝⁶ : CommRing A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra A S
inst✝³ : IsScalarTower R A S
inst✝² : IsIntegralClosure A R S
inst✝¹ : IsDomain A
inst✝ : Nontrivial R
I : Ideal A
⊢ ¬I = ⊥ → ¬comap (algebraMap R A) I = ⊥
Theorem: IsCompl.sup_inf
File: Mathlib/Order/Disjoint.lean

tactic: rw [inf_sup_right, ← inf_assoc, h.inf_eq_bot, bot_inf_eq, bot_sup_eq, inf_left_comm,
h'.inf_eq_bot, inf_bot_eq]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z x' y' : α
h : IsCompl x y
h' : IsCompl x' y'
⊢ (x ⊔ x') ⊓ (y ⊓ y') = ⊥

tactic: rw [sup_inf_left, @sup_comm _ _ x, sup_assoc, h.sup_eq_top, sup_top_eq, top_inf_eq,
sup_assoc, sup_left_comm, h'.sup_eq_top, sup_top_eq]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z x' y' : α
h : IsCompl x y
h' : IsCompl x' y'
⊢ x ⊔ x' ⊔ y ⊓ y' = ⊤
Theorem: SimpleGraph.chromaticNumber_pos
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: apply le_csInf (colorable_set_nonempty_of_colorable hc)
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
⊢ 0 < chromaticNumber G

tactic: intro m hm
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
⊢ ∀ (b : ℕ), b ∈ {n | Colorable G n} → Nat.succ 0 ≤ b

tactic: by_contra h'
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
m : ℕ
hm : m ∈ {n | Colorable G n}
⊢ Nat.succ 0 ≤ m

tactic: simp only [not_le, Nat.lt_one_iff] at h'
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
m : ℕ
hm : m ∈ {n | Colorable G n}
h' : ¬Nat.succ 0 ≤ m
⊢ False

tactic: obtain ⟨i, hi⟩ := hm.some (Classical.arbitrary V)
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
m : ℕ
hm : m ∈ {n | Colorable G n}
h' : m < Nat.succ 0
⊢ False

tactic: have h₁: i < 0 := lt_of_lt_of_le hi (Nat.le_of_lt_succ h')
state_before: case mk
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
m : ℕ
hm : m ∈ {n | Colorable G n}
h' : m < Nat.succ 0
i : ℕ
hi : i < m
⊢ False

tactic: exact Nat.not_lt_zero _ h₁
state_before: case mk
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
n : ℕ
hc : Colorable G n
m : ℕ
hm : m ∈ {n | Colorable G n}
h' : m < Nat.succ 0
i : ℕ
hi : i < m
h₁ : i < 0
⊢ False
Theorem: Colex.mem_le_of_singleton_le
File: Mathlib/Combinatorics/Colex.lean

tactic: simp only [← not_lt]
state_before: α : Type u_1
inst✝ : LinearOrder α
r : α
s : Finset α
⊢ toColex {r} ≤ toColex s ↔ ∃ x, x ∈ s ∧ r ≤ x

tactic: simp [lt_singleton_iff_mem_lt]
state_before: α : Type u_1
inst✝ : LinearOrder α
r : α
s : Finset α
⊢ ¬toColex s < toColex {r} ↔ ∃ x, x ∈ s ∧ ¬x < r