tasksource/leandojo huggingface dataset:
Theorem: ADEInequality.lt_four
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: have h4 : (0 : ℚ) < 4 := by norm_num
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
⊢ q < 4

tactic: contrapose! H
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
h4 : 0 < 4
⊢ q < 4

tactic: rw [sumInv_pqr]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : ¬q < 4
⊢ sumInv {2, q, r} ≤ 1

tactic: have h4r := (not_lt.mp H).trans hqr
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : ¬q < 4
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: simp at H
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
H : ¬q < 4
h4r : 4 ≤ r
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: have hq: (q : ℚ)⁻¹ ≤ 4⁻¹ := by
  rw [inv_le_inv _ h4]
  assumption_mod_cast
  norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: have hr: (r : ℚ)⁻¹ ≤ 4⁻¹ := by
  rw [inv_le_inv _ h4]
  assumption_mod_cast
  norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: calc
  (2⁻¹ + (q : ℚ)⁻¹ + (r : ℚ)⁻¹) ≤ 2⁻¹ + 4⁻¹ + 4⁻¹ := add_le_add (add_le_add le_rfl hq) hr
  _ = 1 := by norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
hr : (↑↑r)⁻¹ ≤ 4⁻¹
⊢ (↑↑2)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹ ≤ 1

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
H : 1 < sumInv {2, q, r}
⊢ 0 < 4

tactic: rw [inv_le_inv _ h4]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
⊢ (↑↑q)⁻¹ ≤ 4⁻¹

tactic: assumption_mod_cast
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
⊢ 4 ≤ ↑↑q

q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
⊢ 0 < ↑↑q

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
⊢ 0 < ↑↑q

tactic: rw [inv_le_inv _ h4]
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ (↑↑r)⁻¹ ≤ 4⁻¹

tactic: assumption_mod_cast
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 4 ≤ ↑↑r

q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 0 < ↑↑r

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
⊢ 0 < ↑↑r

tactic: norm_num
state_before: q r : ℕ+
hqr : q ≤ r
h4 : 0 < 4
h4r : 4 ≤ r
H : 4 ≤ q
hq : (↑↑q)⁻¹ ≤ 4⁻¹
hr : (↑↑r)⁻¹ ≤ 4⁻¹
⊢ 2⁻¹ + 4⁻¹ + 4⁻¹ = 1
Theorem: CategoryTheory.IsPullback.inl_snd'
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine' of_right _ (by simp) (of_isBilimit h)
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPullback b.inl 0 b.snd 0

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPullback (b.inl ≫ b.fst) 0 0 (0 ≫ 0)

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ b.inl ≫ b.snd = 0 ≫ 0
Theorem: Asymptotics.isBigO_one_nat_atTop_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [norm_one, mul_one]
state_before: α : Type ?u.689842
β : Type ?u.689845
E : Type ?u.689848
F : Type ?u.689851
G : Type ?u.689854
E' : Type ?u.689857
F' : Type ?u.689860
G' : Type ?u.689863
E'' : Type u_1
F'' : Type ?u.689869
G'' : Type ?u.689872
R : Type ?u.689875
R' : Type ?u.689878
𝕜 : Type ?u.689881
𝕜' : Type ?u.689884
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✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
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 : ℕ → E''
⊢ (∃ C, ∀ (x : ℕ), ‖f x‖ ≤ C * ‖1‖) ↔ ∃ C, ∀ (n : ℕ), ‖f n‖ ≤ C
Theorem: Equiv.Perm.IsThreeCycle.isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [← card_cycleType_eq_one, h.cycleType, card_singleton]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h : IsThreeCycle σ
⊢ IsCycle σ
Theorem: NormedAddGroupHom.mkNormedAddGroupHom_norm_le'
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type ?u.279839
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.279848
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : V₁ →+ V₂
C : ℝ
h : ∀ (x : V₁), ‖↑f x‖ ≤ C * ‖x‖
x : V₁
⊢ C * ‖x‖ ≤ max C 0 * ‖x‖

tactic: apply le_max_left
state_before: case h
V : Type ?u.279839
V₁ : Type u_1
V₂ : Type u_2
V₃ : Type ?u.279848
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : V₁ →+ V₂
C : ℝ
h : ∀ (x : V₁), ‖↑f x‖ ≤ C * ‖x‖
x : V₁
⊢ C ≤ max C 0
Theorem: FreeAbelianGroup.map_comp
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: simp [map]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
x✝ : α
⊢ ↑(AddMonoidHom.comp (map g) (map f)) (of x✝) = ↑(map (g ∘ f)) (of x✝)
Theorem: mul_mul_invOf_self_cancel'
File: Mathlib/Algebra/Invertible.lean

tactic: simp [mul_assoc]
state_before: α : Type u
inst✝ : Monoid α
a b : α
x✝ : Invertible b
⊢ a * b * ⅟b = a
Theorem: Metric.infEdist_ne_top
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases h with ⟨y, hy⟩
state_before: ι : Sort ?u.57852
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : Set.Nonempty s
⊢ infEdist x s ≠ ⊤

tactic: exact ne_top_of_le_ne_top (edist_ne_top _ _) (infEdist_le_edist_of_mem hy)
state_before: case intro
ι : Sort ?u.57852
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y✝ : α
Φ : α → β
y : α
hy : y ∈ s
⊢ infEdist x s ≠ ⊤
Theorem: Pmf.toOuterMeasure_ofMultiset_apply
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp_rw [div_eq_mul_inv, ← ENNReal.tsum_mul_right, toOuterMeasure_apply]
state_before: α : Type u_1
β : Type ?u.184861
γ : Type ?u.184864
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ ↑(toOuterMeasure (ofMultiset s hs)) t =
    (∑' (x : α), ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s))) / ↑(↑Multiset.card s)

tactic: refine' tsum_congr fun x => _
state_before: α : Type u_1
β : Type ?u.184861
γ : Type ?u.184864
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ (∑' (x : α), Set.indicator t (↑(ofMultiset s hs)) x) =
    ∑' (i : α), ↑(Multiset.count i (Multiset.filter (fun x => x ∈ t) s)) * (↑(↑Multiset.card s))⁻¹

tactic: by_cases hx : x ∈ t <;> simp [Set.indicator, hx, div_eq_mul_inv]
state_before: α : Type u_1
β : Type ?u.184861
γ : Type ?u.184864
s : Multiset α
hs : s ≠ 0
t : Set α
x : α
⊢ Set.indicator t (↑(ofMultiset s hs)) x =
    ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s)) * (↑(↑Multiset.card s))⁻¹
Theorem: Subgroup.subgroupOf_inj
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simpa only [SetLike.ext_iff, mem_inf, mem_subgroupOf, and_congr_left_iff] using Subtype.forall
state_before: G : Type u_1
G' : Type ?u.291162
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.291171
inst✝² : AddGroup A
H K✝ : Subgroup G
k : Set G
N : Type ?u.291192
inst✝¹ : Group N
P : Type ?u.291198
inst✝ : Group P
H₁ H₂ K : Subgroup G
⊢ subgroupOf H₁ K = subgroupOf H₂ K ↔ H₁ ⊓ K = H₂ ⊓ K
Theorem: Ideal.map_snd_prod
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: ext x
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
⊢ map (RingHom.snd R S) (prod I J) = J

tactic: rw [mem_map_iff_of_surjective (RingHom.snd R S) Prod.snd_surjective]
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : S
⊢ x ∈ map (RingHom.snd R S) (prod I J) ↔ x ∈ J

tactic: exact
  ⟨by
    rintro ⟨x, ⟨h, rfl⟩⟩
    exact h.2, fun h => ⟨⟨0, x⟩, ⟨⟨Ideal.zero_mem _, h⟩, rfl⟩⟩⟩
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : S
⊢ (∃ x_1, x_1 ∈ prod I J ∧ ↑(RingHom.snd R S) x_1 = x) ↔ x ∈ J

tactic: rintro ⟨x, ⟨h, rfl⟩⟩
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : S
⊢ (∃ x_1, x_1 ∈ prod I J ∧ ↑(RingHom.snd R S) x_1 = x) → x ∈ J

tactic: exact h.2
state_before: case intro.intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : R × S
h : x ∈ prod I J
⊢ ↑(RingHom.snd R S) x ∈ J
Theorem: Bool.and_intro
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {a b : Bool}, a = true → b = true → (a && b) = true
Theorem: Filter.map₂_left_identity
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_pure_left, show f a = id from funext h, map_id]
state_before: α : Type u_2
α' : Type ?u.45119
β : Type u_1
β' : Type ?u.45125
γ : Type ?u.45128
γ' : Type ?u.45131
δ : Type ?u.45134
δ' : Type ?u.45137
ε : Type ?u.45140
ε' : Type ?u.45143
m : α → β → γ
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a✝ : α
b : β
c : γ
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
l : Filter β
⊢ map₂ f (pure a) l = l
Theorem: UniqueFactorizationMonoid.dvd_pow_iff_dvd_of_squarefree
File: Mathlib/Algebra/Squarefree.lean

tactic: classical
  haveI := UniqueFactorizationMonoid.toGCDMonoid R
  exact ⟨hsq.isRadical n y, fun h => h.pow h0⟩
state_before: R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
x y : R
n : ℕ
hsq : Squarefree x
h0 : n ≠ 0
⊢ x ∣ y ^ n ↔ x ∣ y

tactic: haveI := UniqueFactorizationMonoid.toGCDMonoid R
state_before: R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
x y : R
n : ℕ
hsq : Squarefree x
h0 : n ≠ 0
⊢ x ∣ y ^ n ↔ x ∣ y

tactic: exact ⟨hsq.isRadical n y, fun h => h.pow h0⟩
state_before: R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
x y : R
n : ℕ
hsq : Squarefree x
h0 : n ≠ 0
this : GCDMonoid R
⊢ x ∣ y ^ n ↔ x ∣ y
Theorem: Filter.disjoint_principal_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [← subset_compl_iff_disjoint_left, disjoint_principal_left, mem_principal]
state_before: α : Type u_1
β : Type ?u.57128
γ : Type ?u.57131
ι : Sort ?u.57134
ι' : Sort ?u.57137
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s t : Set α
⊢ Disjoint (𝓟 s) (𝓟 t) ↔ Disjoint s t
Theorem: CategoryTheory.Limits.Pi.reindex_inv_π
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: simp [Iso.inv_comp_eq]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasProduct f
inst✝ : HasProduct (f ∘ ↑ε)
b : β
⊢ (reindex ε f).inv ≫ π (f ∘ ↑ε) b = π f (↑ε b)
Theorem: Nat.coprime_add_mul_right_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_add_mul_right_left]
state_before: m n k : ℕ
⊢ coprime (m + k * n) n ↔ coprime m n
Theorem: Finset.preimage_empty
File: Mathlib/Data/Finset/Preimage.lean

tactic: simp [InjOn]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β
⊢ InjOn f (f ⁻¹' ↑∅)

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β
⊢ ↑(preimage ∅ f (_ : ∀ (a : α), a ∈ f ⁻¹' ↑∅ → ∀ (a_2 : α), a_2 ∈ f ⁻¹' ↑∅ → f a = f a_2 → a = a_2)) = ↑∅
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.diagonal
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: introv h
state_before: C : Type u
inst✝² : Category C
D : Type ?u.79385
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
hP' : RespectsIso P
⊢ ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), MorphismProperty.diagonal P g → MorphismProperty.diagonal P pullback.fst

tactic: rw [diagonal_iff, diagonal_pullback_fst, hP'.cancel_left_isIso, hP'.cancel_right_isIso]
state_before: C : Type u
inst✝² : Category C
D : Type ?u.79385
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
hP' : RespectsIso P
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : MorphismProperty.diagonal P g
⊢ MorphismProperty.diagonal P pullback.fst

tactic: exact hP.baseChange_map f _ (by simpa)
state_before: C : Type u
inst✝² : Category C
D : Type ?u.79385
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
hP' : RespectsIso P
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : MorphismProperty.diagonal P g
⊢ P ((baseChange f).map (Over.homMk (pullback.diagonal g))).left

tactic: simpa
state_before: C : Type u
inst✝² : Category C
D : Type ?u.79385
inst✝¹ : Category D
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : StableUnderBaseChange P
hP' : RespectsIso P
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : MorphismProperty.diagonal P g
⊢ P (Over.homMk (pullback.diagonal g)).left
Theorem: Subsemigroup.mem_iInf
File: Mathlib/GroupTheory/Subsemigroup/Basic.lean

tactic: simp only [iInf, mem_sInf, Set.forall_range_iff]
state_before: M : Type u_2
N : Type ?u.9228
A : Type ?u.9231
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S✝ : Subsemigroup M
ι : Sort u_1
S : ι → Subsemigroup M
x : M
⊢ (x ∈ ⨅ (i : ι), S i) ↔ ∀ (i : ι), x ∈ S i
Theorem: Nat.not_dvd_of_between_consec_multiples
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rintro ⟨d, rfl⟩
state_before: m n k l : ℕ
h1 : n * k < m
h2 : m < n * (k + 1)
⊢ ¬n ∣ m

tactic: exact Monotone.ne_of_lt_of_lt_nat (Covariant.monotone_of_const n) k h1 h2 d rfl
state_before: case intro
n k l d : ℕ
h1 : n * k < n * d
h2 : n * d < n * (k + 1)
⊢ False
Theorem: pochhammer_mul
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: induction' m with m ih
state_before: S : Type u
inst✝ : Semiring S
n m : ℕ
⊢ pochhammer S n * comp (pochhammer S m) (X + ↑n) = pochhammer S (n + m)

tactic: simp
state_before: case zero
S : Type u
inst✝ : Semiring S
n : ℕ
⊢ pochhammer S n * comp (pochhammer S Nat.zero) (X + ↑n) = pochhammer S (n + Nat.zero)

tactic: rw [pochhammer_succ_right, Polynomial.mul_X_add_nat_cast_comp, ← mul_assoc, ih,
  Nat.succ_eq_add_one, ← add_assoc, pochhammer_succ_right, Nat.cast_add, add_assoc]
state_before: case succ
S : Type u
inst✝ : Semiring S
n m : ℕ
ih : pochhammer S n * comp (pochhammer S m) (X + ↑n) = pochhammer S (n + m)
⊢ pochhammer S n * comp (pochhammer S (Nat.succ m)) (X + ↑n) = pochhammer S (n + Nat.succ m)
Theorem: Real.sSup_le
File: Mathlib/Data/Real/Basic.lean

tactic: rcases S.eq_empty_or_nonempty with (rfl | hS₂)
state_before: x y : ℝ
S : Set ℝ
a : ℝ
hS : ∀ (x : ℝ), x ∈ S → x ≤ a
ha : 0 ≤ a
⊢ sSup S ≤ a

tactic: exacts [sSup_empty.trans_le ha, csSup_le hS₂ hS]
state_before: case inl
x y a : ℝ
ha : 0 ≤ a
hS : ∀ (x : ℝ), x ∈ ∅ → x ≤ a
⊢ sSup ∅ ≤ a

case inr
x y : ℝ
S : Set ℝ
a : ℝ
hS : ∀ (x : ℝ), x ∈ S → x ≤ a
ha : 0 ≤ a
hS₂ : Set.Nonempty S
⊢ sSup S ≤ a
Theorem: Submonoid.LocalizationMap.inv_unique
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← one_mul _⁻¹, Units.val_mul, mul_inv_left]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.575607
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y : { x // x ∈ S }
z : N
H : ↑f ↑y * z = 1
⊢ ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y)⁻¹ = z

tactic: exact H.symm
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.575607
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y : { x // x ∈ S }
z : N
H : ↑f ↑y * z = 1
⊢ ↑1 = ↑f ↑y * z
Theorem: MulHom.comp_mul
File: Mathlib/Algebra/Hom/Group.lean

tactic: ext
state_before: α : Type ?u.204587
β : Type ?u.204590
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.204602
H : Type ?u.204605
F : Type ?u.204608
inst✝² : Mul M
inst✝¹ : CommSemigroup N
inst✝ : CommSemigroup P
g : N →ₙ* P
f₁ f₂ : M →ₙ* N
⊢ comp g (f₁ * f₂) = comp g f₁ * comp g f₂

tactic: simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
state_before: case h
α : Type ?u.204587
β : Type ?u.204590
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.204602
H : Type ?u.204605
F : Type ?u.204608
inst✝² : Mul M
inst✝¹ : CommSemigroup N
inst✝ : CommSemigroup P
g : N →ₙ* P
f₁ f₂ : M →ₙ* N
x✝ : M
⊢ ↑(comp g (f₁ * f₂)) x✝ = ↑(comp g f₁ * comp g f₂) x✝
Theorem: Filter.blimsup_congr
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [blimsup_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
⊢ blimsup u f p = blimsup v f p

tactic: congr with b
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
⊢ sInf {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = blimsup v f p

tactic: refine' eventually_congr (h.mono fun x hx => ⟨fun h₁ h₂ => _, fun h₁ h₂ => _⟩)
state_before: case e_a.h
α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
b : α
⊢ b ∈ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ b ∈ {a | ∀ᶠ (x : β) in f, p x → v x ≤ a}

tactic: rw [← hx h₂]
state_before: case e_a.h.refine'_1
α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
b : α
x : β
hx : p x → u x = v x
h₁ : p x → u x ≤ b
h₂ : p x
⊢ v x ≤ b

tactic: exact h₁ h₂
state_before: case e_a.h.refine'_1
α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
b : α
x : β
hx : p x → u x = v x
h₁ : p x → u x ≤ b
h₂ : p x
⊢ u x ≤ b

tactic: rw [hx h₂]
state_before: case e_a.h.refine'_2
α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
b : α
x : β
hx : p x → u x = v x
h₁ : p x → v x ≤ b
h₂ : p x
⊢ u x ≤ b

tactic: exact h₁ h₂
state_before: case e_a.h.refine'_2
α : Type u_2
β : Type u_1
γ : Type ?u.81206
ι : Type ?u.81209
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u v : β → α
p : β → Prop
h : ∀ᶠ (a : β) in f, p a → u a = v a
b : α
x : β
hx : p x → u x = v x
h₁ : p x → v x ≤ b
h₂ : p x
⊢ v x ≤ b
Theorem: Nat.shiftLeft_eq
File: Std/Data/Nat/Lemmas.lean

tactic: simp [pow_succ, Nat.mul_assoc, Nat.mul_left_comm, Nat.mul_comm]
state_before: a b✝ b : Nat
⊢ 2 * a * 2 ^ b = a * 2 ^ (b + 1)
Theorem: UniformCauchySeqOnFilter.mono_left
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: intro u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
⊢ UniformCauchySeqOnFilter F p'' p'

tactic: have := (hf u hu).filter_mono (p'.prod_mono_left (Filter.prod_mono hp hp))
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.fst.fst m.snd, F m.fst.snd m.snd) ∈ u

tactic: exact this.mono (by simp)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.fst.fst m.snd, F m.fst.snd m.snd) ∈ u

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u
⊢ ∀ (x : (ι × ι) × α), (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u → (F x.fst.fst x.snd, F x.fst.snd x.snd) ∈ u
Theorem: IsExtreme.inter
File: Mathlib/Analysis/Convex/Extreme.lean

tactic: use Subset.trans (inter_subset_left _ _) hAB.1
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2321
ι : Type ?u.2324
π : ι → Type ?u.2329
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hAB : IsExtreme 𝕜 A B
hAC : IsExtreme 𝕜 A C
⊢ IsExtreme 𝕜 A (B ∩ C)

tactic: rintro x₁ hx₁A x₂ hx₂A x ⟨hxB, hxC⟩ hx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2321
ι : Type ?u.2324
π : ι → Type ?u.2329
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hAB : IsExtreme 𝕜 A B
hAC : IsExtreme 𝕜 A C
⊢ ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → ∀ ⦃x : E⦄, x ∈ B ∩ C → x ∈ openSegment 𝕜 x₁ x₂ → x₁ ∈ B ∩ C ∧ x₂ ∈ B ∩ C

tactic: obtain ⟨hx₁B, hx₂B⟩ := hAB.2 hx₁A hx₂A hxB hx
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2321
ι : Type ?u.2324
π : ι → Type ?u.2329
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hAC : IsExtreme 𝕜 A C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxB : x ∈ B
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
⊢ x₁ ∈ B ∩ C ∧ x₂ ∈ B ∩ C

tactic: obtain ⟨hx₁C, hx₂C⟩ := hAC.2 hx₁A hx₂A hxC hx
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2321
ι : Type ?u.2324
π : ι → Type ?u.2329
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hAC : IsExtreme 𝕜 A C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxB : x ∈ B
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
hx₁B : x₁ ∈ B
hx₂B : x₂ ∈ B
⊢ x₁ ∈ B ∩ C ∧ x₂ ∈ B ∩ C

tactic: exact ⟨⟨hx₁B, hx₁C⟩, hx₂B, hx₂C⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2321
ι : Type ?u.2324
π : ι → Type ?u.2329
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x✝ : E
hAB : IsExtreme 𝕜 A B
hAC : IsExtreme 𝕜 A C
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
x : E
hxB : x ∈ B
hxC : x ∈ C
hx : x ∈ openSegment 𝕜 x₁ x₂
hx₁B : x₁ ∈ B
hx₂B : x₂ ∈ B
hx₁C : x₁ ∈ C
hx₂C : x₂ ∈ C
⊢ x₁ ∈ B ∩ C ∧ x₂ ∈ B ∩ C
Theorem: WithTop.coe_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: by_cases ha : a = 0
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
⊢ ↑(a * b) = ↑a * ↑b

tactic: simp [ha]
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
ha : a = 0
⊢ ↑(a * b) = ↑a * ↑b

tactic: by_cases hb : b = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
ha : ¬a = 0
⊢ ↑(a * b) = ↑a * ↑b

tactic: simp [hb]
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
ha : ¬a = 0
hb : b = 0
⊢ ↑(a * b) = ↑a * ↑b

tactic: simp [*, mul_def]
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
ha : ¬a = 0
hb : ¬b = 0
⊢ ↑(a * b) = ↑a * ↑b

tactic: rfl
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : α
ha : ¬a = 0
hb : ¬b = 0
⊢ ↑(a * b) = Option.map₂ (fun x x_1 => x * x_1) ↑a ↑b