1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: UniformConcaveOn.strictConcaveOn
File: Mathlib/Analysis/Convex/Strong.lean

tactic: refine ⟨hf.1, fun x hx y hy hxy a b ha hb hab ↦ (hf.2 hx hy ha.le hb.le hab).trans_lt' <|
  lt_add_of_pos_right _ ?_⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
⊢ StrictConcaveOn ℝ s f
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖

tactic: rw [← sub_ne_zero, ← norm_pos_iff] at hxy
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖

tactic: have := hφ _ hxy.ne'
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
this : 0 < φ ‖x - y‖
⊢ 0 < a * b * φ ‖x - y‖

tactic: positivity
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
this : 0 < φ ‖x - y‖
⊢ 0 < a * b * φ ‖x - y‖
state_after: no goals
Theorem: Field.primitive_element_iff_algHom_eq_of_eval'
File: Mathlib/FieldTheory/PrimitiveElement.lean

tactic: classical
simp_rw [primitive_element_iff_minpoly_natDegree_eq, ← card_rootSet_eq_natDegree (K := A)
  (IsSeparable.separable F α) (hA _), ← toFinset_card,
  ← (Algebra.IsAlgebraic.of_finite F E).range_eval_eq_rootSet_minpoly_of_splits _ hA α,
  ← AlgHom.card_of_splits F E A hA, Fintype.card, toFinset_range, Finset.card_image_iff,
  Finset.coe_univ, ← injective_iff_injOn_univ]
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝¹¹ : Field F✝
inst✝¹⁰ : Field E✝
inst✝⁹ : Algebra F✝ E✝
inst✝⁸ : FiniteDimensional F✝ E✝
inst✝⁷ : IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : IsSeparable F E
A : Type u_5
inst✝¹ : Field A
inst✝ : Algebra F A
hA : ∀ (x : E), Splits (algebraMap F A) (minpoly F x)
α : E
⊢ F⟮α⟯ = ⊤ ↔ Function.Injective fun φ => φ α
state_after: no goals

tactic: simp_rw [primitive_element_iff_minpoly_natDegree_eq, ← card_rootSet_eq_natDegree (K := A)
  (IsSeparable.separable F α) (hA _), ← toFinset_card,
  ← (Algebra.IsAlgebraic.of_finite F E).range_eval_eq_rootSet_minpoly_of_splits _ hA α,
  ← AlgHom.card_of_splits F E A hA, Fintype.card, toFinset_range, Finset.card_image_iff,
  Finset.coe_univ, ← injective_iff_injOn_univ]
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝¹¹ : Field F✝
inst✝¹⁰ : Field E✝
inst✝⁹ : Algebra F✝ E✝
inst✝⁸ : FiniteDimensional F✝ E✝
inst✝⁷ : IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : IsSeparable F E
A : Type u_5
inst✝¹ : Field A
inst✝ : Algebra F A
hA : ∀ (x : E), Splits (algebraMap F A) (minpoly F x)
α : E
⊢ F⟮α⟯ = ⊤ ↔ Function.Injective fun φ => φ α
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isRat_pow
File: Mathlib/Tactic/NormNum/Pow.lean

tactic: rintro rfl ⟨_, rfl⟩ ⟨rfl⟩ (rfl : an ^ b = _) (rfl : ad ^ b = _)
state_before: α : Type u_1
inst✝ : Ring α
f : α → ℕ → α
a : α
an cn : ℤ
ad b b' cd : ℕ
⊢ f = HPow.hPow → IsRat a an ad → IsNat b b' → an.pow b' = cn → ad.pow b' = cd → IsRat (f a b) cn cd
state_after: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: have := invertiblePow (ad:α) b
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)
state_after: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible (↑ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: rw [← Nat.cast_pow] at this
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible (↑ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)
state_after: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)

tactic: use this
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ IsRat ((↑an * ⅟↑ad) ^ b) (an ^ b) (ad ^ b)
state_after: case eq
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ (↑an * ⅟↑ad) ^ b = ↑(an ^ b) * ⅟↑(ad ^ b)

tactic: simp [invOf_pow, Commute.mul_pow]
state_before: case eq
α : Type u_1
inst✝ : Ring α
an : ℤ
ad b : ℕ
inv✝ : Invertible ↑ad
this : Invertible ↑(ad ^ b)
⊢ (↑an * ⅟↑ad) ^ b = ↑(an ^ b) * ⅟↑(ad ^ b)
state_after: no goals
Theorem: gcd_mul_right'
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simp only [mul_comm, gcd_mul_left']
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
⊢ Associated (gcd (b * a) (c * a)) (gcd b c * a)
state_after: no goals
Theorem: acc_iff_cluster
File: Mathlib/Topology/Basic.lean

tactic: rw [AccPt, nhdsWithin, ClusterPt, inf_assoc]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
F : Filter X
⊢ AccPt x F ↔ ClusterPt x (𝓟 {x}ᶜ ⊓ F)
state_after: no goals
Theorem: Filter.eventuallyConst_pred'
File: Mathlib/Order/Filter/EventuallyConst.lean

tactic: simp only [eventuallyConst_iff_exists_eventuallyEq, Prop.exists_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f : α → β
p : α → Prop
⊢ EventuallyConst p l ↔ (p =ᶠ[l] fun x => False) ∨ p =ᶠ[l] fun x => True
state_after: no goals
Theorem: Cardinal.natCast_add_one_le_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Order.succ_le_iff, Cardinal.succ_natCast]
state_before: α β : Type u
n : ℕ
c : Cardinal.{u_1}
⊢ ↑n + 1 ≤ c ↔ ↑n < c
state_after: no goals
Theorem: Set.piecewise_singleton
File: Mathlib/Data/Set/Function.lean

tactic: ext y
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
⊢ {x}.piecewise f g = update g x (f x)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
⊢ {x}.piecewise f g y = update g x (f x) y

tactic: by_cases hy : y = x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
⊢ {x}.piecewise f g y = update g x (f x) y
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
hy : y = x
⊢ {x}.piecewise f g y = update g x (f x) y

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
hy : ¬y = x
⊢ {x}.piecewise f g y = update g x (f x) y

tactic: subst y
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
hy : y = x
⊢ {x}.piecewise f g y = update g x (f x) y
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
⊢ {x}.piecewise f g x = update g x (f x) x

tactic: simp
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
⊢ {x}.piecewise f g x = update g x (f x) x
state_after: no goals

tactic: simp [hy]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
x : α
inst✝¹ : (y : α) → Decidable (y ∈ {x})
inst✝ : DecidableEq α
f g : α → β
y : α
hy : ¬y = x
⊢ {x}.piecewise f g y = update g x (f x) y
state_after: no goals
Theorem: NormedAddGroupHom.isQuotientQuotient
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: simpa [S.ker_normedMk] using quotient_norm_mk_eq _ m
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ ‖S.normedMk m‖ = sInf ((fun m_1 => ‖m + m_1‖) '' ↑S.normedMk.ker)
state_after: no goals
Theorem: Ring.multichoose_zero_right'
File: Mathlib/RingTheory/Binomial.lean

tactic: refine nsmul_right_injective (Nat.factorial 0) (Nat.factorial_ne_zero 0) ?_
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ multichoose r 0 = r ^ 0
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose r 0) = (fun x => Nat.factorial 0 • x) (r ^ 0)

tactic: simp only
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose r 0) = (fun x => Nat.factorial 0 • x) (r ^ 0)
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 0 • multichoose r 0 = Nat.factorial 0 • r ^ 0

tactic: rw [factorial_nsmul_multichoose_eq_ascPochhammer, ascPochhammer_zero, smeval_one, Nat.factorial]
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 0 • multichoose r 0 = Nat.factorial 0 • r ^ 0
state_after: no goals
Theorem: Asymptotics.isBigO_top
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp_rw [isBigO_iff, eventually_top]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ f =O[⊤] g ↔ ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖
state_after: no goals
Theorem: Module.End.mem_maxGenEigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: simp only [maxGenEigenspace, ← mem_genEigenspace, Submodule.mem_iSup_of_chain]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
m : M
⊢ m ∈ f.maxGenEigenspace μ ↔ ∃ k, ((f - μ • 1) ^ k) m = 0
state_after: no goals
Theorem: CategoryTheory.Subobject.le_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: rintro f g h ⟨k⟩ ⟨l⟩
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h f g : Subobject A
⊢ ∀ (a₁ a₂ a₃ : MonoOver A),
    Quotient.mk'' a₁ ≤ Quotient.mk'' a₂ →
      Quotient.mk'' a₁ ≤ Quotient.mk'' a₃ → Quotient.mk'' a₁ ≤ (inf.obj (Quotient.mk'' a₂)).obj (Quotient.mk'' a₃)
state_after: case intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h✝ f✝ g✝ : Subobject A
f g h : MonoOver A
k : f ⟶ g
l : f ⟶ h
⊢ Quotient.mk'' f ≤ (inf.obj (Quotient.mk'' g)).obj (Quotient.mk'' h)

tactic: exact ⟨MonoOver.leInf _ _ _ k l⟩
state_before: case intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
A : C
h✝ f✝ g✝ : Subobject A
f g h : MonoOver A
k : f ⟶ g
l : f ⟶ h
⊢ Quotient.mk'' f ≤ (inf.obj (Quotient.mk'' g)).obj (Quotient.mk'' h)
state_after: no goals
Theorem: LipschitzOnWith.dimH_image_le
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: simpa using h.holderOnWith.dimH_image_le zero_lt_one
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s t : Set X
h : LipschitzOnWith K f s
⊢ dimH (f '' s) ≤ dimH s
state_after: no goals
Theorem: Set.image_multiset_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

tactic: simpa only [Multiset.quot_mk_to_coe, Multiset.prod_coe, Multiset.map_coe] using
  image_list_prod f
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : F
⊢ ∀ (a : List (Set α)), ⇑f '' Multiset.prod ⟦a⟧ = (Multiset.map (fun s => ⇑f '' s) ⟦a⟧).prod
state_after: no goals
Theorem: Finset.truncatedSup_singleton
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: simp [truncatedSup]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ {b}.truncatedSup a = if a ≤ b then b else ⊤
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ (if h : a ≤ b then (filter (fun b => a ≤ b) {b}).sup' ⋯ fun x => x else ⊤) = if a ≤ b then b else ⊤

tactic: split_ifs <;> simp [Finset.filter_true_of_mem, *]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeSup α
inst✝⁴ : OrderTop α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeSup β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b✝ b a : α
⊢ (if h : a ≤ b then (filter (fun b => a ≤ b) {b}).sup' ⋯ fun x => x else ⊤) = if a ≤ b then b else ⊤
state_after: no goals
Theorem: Nat.div_le_iff_le_mul_add_pred
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [← Nat.lt_succ_iff, div_lt_iff_lt_mul hb, succ_mul, Nat.mul_comm]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a / b ≤ c ↔ a ≤ b * c + (b - 1)
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a < b * c + b ↔ a ≤ b * c + (b - 1)

tactic: cases hb <;> exact Nat.lt_succ_iff
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a < b * c + b ↔ a ≤ b * c + (b - 1)
state_after: no goals
Theorem: LucasLehmer.ω_pow_eq_one
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [← pow_mul, ← Nat.pow_succ]
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ω ^ 2 ^ (p' + 2) = (ω ^ 2 ^ (p' + 1)) ^ 2
state_after: no goals

tactic: rw [ω_pow_eq_neg_one p' h]
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ (ω ^ 2 ^ (p' + 1)) ^ 2 = (-1) ^ 2
state_after: no goals

tactic: simp
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ (-1) ^ 2 = 1
state_after: no goals
Theorem: Nat.Coprime.mul_add_mul_ne_mul
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: intro h
state_before: m n a b : ℕ
cop : m.Coprime n
ha : a ≠ 0
hb : b ≠ 0
⊢ a * m + b * n ≠ m * n
state_after: m n a b : ℕ
cop : m.Coprime n
ha : a ≠ 0
hb : b ≠ 0
h : a * m + b * n = m * n
⊢ False

tactic: obtain ⟨x, rfl⟩ : n ∣ a :=
  cop.symm.dvd_of_dvd_mul_right
    ((Nat.dvd_add_iff_left (Nat.dvd_mul_left n b)).mpr
      ((congr_arg _ h).mpr (Nat.dvd_mul_left n m)))
state_before: m n a b : ℕ
cop : m.Coprime n
ha : a ≠ 0
hb : b ≠ 0
h : a * m + b * n = m * n
⊢ False
state_after: case intro
m n b : ℕ
cop : m.Coprime n
hb : b ≠ 0
x : ℕ
ha : n * x ≠ 0
h : n * x * m + b * n = m * n
⊢ False

tactic: obtain ⟨y, rfl⟩ : m ∣ b :=
  cop.dvd_of_dvd_mul_right
    ((Nat.dvd_add_iff_right (Nat.dvd_mul_left m (n * x))).mpr
      ((congr_arg _ h).mpr (Nat.dvd_mul_right m n)))
state_before: case intro
m n b : ℕ
cop : m.Coprime n
hb : b ≠ 0
x : ℕ
ha : n * x ≠ 0
h : n * x * m + b * n = m * n
⊢ False
state_after: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : n * x ≠ 0
y : ℕ
hb : m * y ≠ 0
h : n * x * m + m * y * n = m * n
⊢ False

tactic: rw [mul_comm, mul_ne_zero_iff, ← one_le_iff_ne_zero] at ha hb
state_before: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : n * x ≠ 0
y : ℕ
hb : m * y ≠ 0
h : n * x * m + m * y * n = m * n
⊢ False
state_after: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : 1 ≤ x ∧ n ≠ 0
y : ℕ
hb : 1 ≤ y ∧ m ≠ 0
h : n * x * m + m * y * n = m * n
⊢ False

tactic: refine mul_ne_zero hb.2 ha.2 (eq_zero_of_mul_eq_self_left (ne_of_gt (add_le_add ha.1 hb.1)) ?_)
state_before: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : 1 ≤ x ∧ n ≠ 0
y : ℕ
hb : 1 ≤ y ∧ m ≠ 0
h : n * x * m + m * y * n = m * n
⊢ False
state_after: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : 1 ≤ x ∧ n ≠ 0
y : ℕ
hb : 1 ≤ y ∧ m ≠ 0
h : n * x * m + m * y * n = m * n
⊢ (x + y) * (m * n) = m * n

tactic: rw [← mul_assoc, ← h, add_mul, add_mul, mul_comm _ n, ← mul_assoc, mul_comm y]
state_before: case intro.intro
m n : ℕ
cop : m.Coprime n
x : ℕ
ha : 1 ≤ x ∧ n ≠ 0
y : ℕ
hb : 1 ≤ y ∧ m ≠ 0
h : n * x * m + m * y * n = m * n
⊢ (x + y) * (m * n) = m * n
state_after: no goals
Theorem: ModuleCat.smul_naturality
File: Mathlib/Algebra/Category/ModuleCat/Basic.lean

tactic: ext x
state_before: R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
M✝ N✝ M N : ModuleCat R
f : M ⟶ N
r : R
⊢ (forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r = M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f
state_after: case w
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
M✝ N✝ M N : ModuleCat R
f : M ⟶ N
r : R
x : ↑((forget₂ (ModuleCat R) AddCommGrp).obj M)
⊢ ((forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r) x = (M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f) x

tactic: exact (f.map_smul r x).symm
state_before: case w
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
M✝ N✝ M N : ModuleCat R
f : M ⟶ N
r : R
x : ↑((forget₂ (ModuleCat R) AddCommGrp).obj M)
⊢ ((forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r) x = (M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f) x
state_after: no goals
Theorem: minpoly.ker_aeval_eq_span_minpoly
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: ext p
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
⊢ RingHom.ker (Polynomial.aeval x) = Submodule.span A[X] {minpoly A x}
state_after: case h
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
⊢ p ∈ RingHom.ker (Polynomial.aeval x) ↔ p ∈ Submodule.span A[X] {minpoly A x}

tactic: simp_rw [RingHom.mem_ker, ← minpoly.dvd_iff, Submodule.mem_span_singleton,
  dvd_iff_exists_eq_mul_left, smul_eq_mul, eq_comm (a := p)]
state_before: case h
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
⊢ p ∈ RingHom.ker (Polynomial.aeval x) ↔ p ∈ Submodule.span A[X] {minpoly A x}
state_after: no goals
Theorem: cfcₙ_map_quasispectrum
File: Mathlib/Topology/ContinuousFunction/NonUnitalFunctionalCalculus.lean

tactic: simp [cfcₙ_apply f a, cfcₙHom_map_quasispectrum (p := p)]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha : autoParam (p a) _auto✝
⊢ σₙ R (cfcₙ f a) = f '' σₙ R a
state_after: no goals
Theorem: Nat.coprime_div_gcd_div_gcd
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: rw [coprime_iff_gcd_eq_one, gcd_div (gcd_dvd_left m n) (gcd_dvd_right m n), Nat.div_self H]
state_before: m n : Nat
H : 0 < m.gcd n
⊢ (m / m.gcd n).Coprime (n / m.gcd n)
state_after: no goals
Theorem: Filter.HasBasis.sup_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [(hl.sup' (hasBasis_principal t)).mem_iff, PProd.exists, exists_prop, and_true_iff,
  Unique.exists_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
t u : Set α
⊢ u ∈ l ⊔ 𝓟 t ↔ ∃ i, p i ∧ s i ∪ t ⊆ u
state_after: no goals