tasksource/leandojo huggingface dataset:
Theorem: Real.ceil_logb_nat_cast
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: obtain rfl | hr := hr.eq_or_lt
state_before: b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr : 0 ≤ r
⊢ ⌈logb (↑b) r⌉ = Int.clog b r

tactic: have hb1' : 1 < (b : ℝ) := Nat.one_lt_cast.mpr hb
state_before: case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
⊢ ⌈logb (↑b) r⌉ = Int.clog b r

tactic: apply le_antisymm
state_before: case inr
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ⌈logb (↑b) r⌉ = Int.clog b r

tactic: rw [logb_zero, Int.clog_zero_right, Int.ceil_zero]
state_before: case inl
b✝ x y : ℝ
b : ℕ
hb : 1 < b
hr : 0 ≤ 0
⊢ ⌈logb (↑b) 0⌉ = Int.clog b 0

tactic: rw [Int.ceil_le, logb_le_iff_le_rpow hb1' hr, rpow_int_cast]
state_before: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ⌈logb (↑b) r⌉ ≤ Int.clog b r

tactic: refine' Int.self_le_zpow_clog hb r
state_before: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ r ≤ ↑b ^ Int.clog b r

tactic: rw [← Int.le_zpow_iff_clog_le hb hr, ← rpow_int_cast b]
state_before: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ Int.clog b r ≤ ⌈logb (↑b) r⌉

tactic: refine' (rpow_logb (zero_lt_one.trans hb1') hb1'.ne' hr).symm.trans_le _
state_before: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ r ≤ ↑b ^ ↑⌈logb (↑b) r⌉

tactic: exact rpow_le_rpow_of_exponent_le hb1'.le (Int.le_ceil _)
state_before: case inr.a
b✝ x y : ℝ
b : ℕ
r : ℝ
hb : 1 < b
hr✝ : 0 ≤ r
hr : 0 < r
hb1' : 1 < ↑b
⊢ ↑b ^ logb (↑b) r ≤ ↑b ^ ↑⌈logb (↑b) r⌉
Theorem: Real.hasStrictDerivAt_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: have A : cos (arctan x) ≠ 0 := (cos_arctan_pos x).ne'
state_before: x : ℝ
⊢ HasStrictDerivAt arctan (↑1 / (↑1 + x ^ 2)) x

tactic: simpa [cos_sq_arctan] using
  tanLocalHomeomorph.hasStrictDerivAt_symm trivial (by simpa) (hasStrictDerivAt_tan A)
state_before: x : ℝ
A : cos (arctan x) ≠ 0
⊢ HasStrictDerivAt arctan (↑1 / (↑1 + x ^ 2)) x

tactic: simpa
state_before: x : ℝ
A : cos (arctan x) ≠ 0
⊢ ↑1 / cos (↑(LocalHomeomorph.symm tanLocalHomeomorph) x) ^ 2 ≠ 0
Theorem: Module.End.mem_eigenspace_iff
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [eigenspace, LinearMap.mem_ker, LinearMap.sub_apply, algebraMap_end_apply, sub_eq_zero]
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
x : M
⊢ x ∈ eigenspace f μ ↔ ↑f x = μ • x
Theorem: Cardinal.sum_add_distrib
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: have := mk_congr (Equiv.sigmaSumDistrib (Quotient.out ∘ f) (Quotient.out ∘ g))
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal
⊢ sum (f + g) = sum f + sum g

tactic: simp only [comp_apply, mk_sigma, mk_sum, mk_out, lift_id] at this
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal
this :
  (#(i : ι) × ((Quotient.out ∘ f) i ⊕ (Quotient.out ∘ g) i)) =
    (#(i : ι) × (Quotient.out ∘ f) i ⊕ (i : ι) × (Quotient.out ∘ g) i)
⊢ sum (f + g) = sum f + sum g

tactic: exact this
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal
this : (sum fun i => f i + g i) = (sum fun i => f i) + sum fun i => g i
⊢ sum (f + g) = sum f + sum g
Theorem: GeneralizedContinuedFraction.convergents'_succ
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: cases' eq_or_ne (fract v) 0 with h h
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ convergents' (of v) (n + 1) = ↑⌊v⌋ + 1 / convergents' (of (fract v)⁻¹) n

tactic: obtain ⟨a, rfl⟩ : ∃ a : ℤ, v = a := ⟨⌊v⌋, eq_of_sub_eq_zero h⟩
state_before: case inl
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v = 0
⊢ convergents' (of v) (n + 1) = ↑⌊v⌋ + 1 / convergents' (of (fract v)⁻¹) n

tactic: rw [convergents'_of_int, fract_intCast, inv_zero, ← cast_zero, convergents'_of_int, cast_zero,
  div_zero, add_zero, floor_intCast]
state_before: case inl.intro
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
n : ℕ
a : ℤ
h : fract ↑a = 0
⊢ convergents' (of ↑a) (n + 1) = ↑⌊↑a⌋ + 1 / convergents' (of (fract ↑a)⁻¹) n

tactic: rw [convergents', of_h_eq_floor, add_right_inj, convergents'Aux_succ_some (of_s_head h)]
state_before: case inr
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ convergents' (of v) (n + 1) = ↑⌊v⌋ + 1 / convergents' (of (fract v)⁻¹) n

tactic: rw [convergents', of_h_eq_floor, add_right_inj, of_s_tail]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ { a := 1, b := ↑⌊(fract v)⁻¹⌋ }.b + convergents'Aux (Stream'.Seq.tail (of v).s) n = convergents' (of (fract v)⁻¹) n
Theorem: OrderHom.coe_iSup
File: Mathlib/Order/Hom/Order.lean

tactic: funext x
state_before: α : Type u_3
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_1
inst✝ : CompleteLattice β
f : ι → α →o β
⊢ ↑(⨆ (i : ι), f i) = ⨆ (i : ι), ↑(f i)

tactic: simp [iSup_apply]
state_before: case h
α : Type u_3
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_1
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ ↑(⨆ (i : ι), f i) x = iSup (fun i => ↑(f i)) x
Theorem: pow_lt_pow_of_lt_left
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: contradiction
state_before: β : Type ?u.224581
A : Type ?u.224584
G : Type ?u.224587
M : Type ?u.224590
R : Type u_1
inst✝ : StrictOrderedSemiring R
a x y : R
n m : ℕ
h : x < y
hx : 0 ≤ x
hn : 0 < 0
⊢ x ^ 0 < y ^ 0

tactic: simpa only [pow_succ'] using
  mul_lt_mul_of_le_of_le' (pow_le_pow_of_le_left hx h.le _) h (pow_pos (hx.trans_lt h) _) hx
state_before: β : Type ?u.224581
A : Type ?u.224584
G : Type ?u.224587
M : Type ?u.224590
R : Type u_1
inst✝ : StrictOrderedSemiring R
a x y : R
n✝ m : ℕ
h : x < y
hx : 0 ≤ x
n : ℕ
x✝ : 0 < n + 1
⊢ x ^ (n + 1) < y ^ (n + 1)
Theorem: AbsoluteValue.IsAdmissible.exists_partition
File: Mathlib/NumberTheory/ClassNumber/AdmissibleAbsoluteValue.lean

tactic: let e := Fintype.equivFin ι
state_before: R : Type u_2
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_1
inst✝ : Fintype ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : IsAdmissible abv
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(↑abv (A i₁ % b - A i₀ % b)) < ↑abv b • ε

tactic: obtain ⟨t, ht⟩ := h.exists_partition' (Fintype.card ι) hε hb (A ∘ e.symm)
state_before: R : Type u_2
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_1
inst✝ : Fintype ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : IsAdmissible abv
e : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(↑abv (A i₁ % b - A i₀ % b)) < ↑abv b • ε

tactic: refine' ⟨t ∘ e, fun i₀ i₁ h ↦ _⟩
state_before: case intro
R : Type u_2
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_1
inst✝ : Fintype ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h : IsAdmissible abv
e : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
t : Fin (Fintype.card ι) → Fin (IsAdmissible.card h ε)
ht : ∀ (i₀ i₁ : Fin (Fintype.card ι)), t i₀ = t i₁ → ↑(↑abv ((A ∘ ↑e.symm) i₁ % b - (A ∘ ↑e.symm) i₀ % b)) < ↑abv b • ε
⊢ ∃ t, ∀ (i₀ i₁ : ι), t i₀ = t i₁ → ↑(↑abv (A i₁ % b - A i₀ % b)) < ↑abv b • ε

tactic: convert (config := {transparency := .default})
  ht (e i₀) (e i₁) h <;> simp only [e.symm_apply_apply]
state_before: case intro
R : Type u_2
inst✝¹ : EuclideanDomain R
abv : AbsoluteValue R ℤ
ι : Type u_1
inst✝ : Fintype ι
ε : ℝ
hε : 0 < ε
b : R
hb : b ≠ 0
A : ι → R
h✝ : IsAdmissible abv
e : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
t : Fin (Fintype.card ι) → Fin (IsAdmissible.card h✝ ε)
ht : ∀ (i₀ i₁ : Fin (Fintype.card ι)), t i₀ = t i₁ → ↑(↑abv ((A ∘ ↑e.symm) i₁ % b - (A ∘ ↑e.symm) i₀ % b)) < ↑abv b • ε
i₀ i₁ : ι
h : (t ∘ ↑e) i₀ = (t ∘ ↑e) i₁
⊢ ↑(↑abv (A i₁ % b - A i₀ % b)) < ↑abv b • ε
Theorem: Set.Iic_union_Ioc'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)

tactic: simp_rw [mem_union, mem_Iic, mem_Ioc, le_max_iff]
state_before: case h
α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
⊢ x ∈ Iic b ∪ Ioc c d ↔ x ∈ Iic (max b d)

tactic: by_cases hc : c < x
state_before: case h
α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
⊢ x ≤ b ∨ c < x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d

tactic: simp only [hc, true_and]
state_before: case pos
α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : c < x
⊢ x ≤ b ∨ c < x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d

tactic: have hxb : x ≤ b := (le_of_not_gt hc).trans h₁.le
state_before: case neg
α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : ¬c < x
⊢ x ≤ b ∨ c < x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d

tactic: simp only [hxb, true_or]
state_before: case neg
α : Type u_1
β : Type ?u.100377
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hc : ¬c < x
hxb : x ≤ b
⊢ x ≤ b ∨ c < x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d
Theorem: one_le_sq_iff_one_le_abs
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [one_pow, abs_one] using @sq_le_sq _ _ 1 x
state_before: β : Type ?u.269979
A : Type ?u.269982
G : Type ?u.269985
M : Type ?u.269988
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y x : R
⊢ 1 ≤ x ^ 2 ↔ 1 ≤ abs x
Theorem: Num.add_one
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases p <;> rfl
state_before: α : Type ?u.173480
p : PosNum
⊢ pos p + 1 = succ (pos p)
Theorem: Quiver.Path.comp_inj'
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: simpa [h] using congr_arg length h_eq
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p₁ p₂ : Path a b
q₁ q₂ : Path b c
h : length p₁ = length p₂
h_eq : comp p₁ q₁ = comp p₂ q₂
⊢ ?m.9164 h h_eq + length q₁ = ?m.9164 h h_eq + length q₂

tactic: rintro ⟨rfl, rfl⟩
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p₁ p₂ : Path a b
q₁ q₂ : Path b c
h : length p₁ = length p₂
⊢ p₁ = p₂ ∧ q₁ = q₂ → comp p₁ q₁ = comp p₂ q₂

tactic: rfl
state_before: case intro
V : Type u
inst✝ : Quiver V
a b c d : V
p₁ : Path a b
q₁ : Path b c
h : length p₁ = length p₁
⊢ comp p₁ q₁ = comp p₁ q₁
Theorem: t2_iff_nhds
File: Mathlib/Topology/Separation.lean

tactic: simp only [t2Space_iff_disjoint_nhds, disjoint_iff, neBot_iff, Ne.def, not_imp_comm]
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
⊢ T2Space α ↔ ∀ {x y : α}, NeBot (𝓝 x ⊓ 𝓝 y) → x = y
Theorem: MulSemiringActionHom.comp_id
File: Mathlib/Algebra/Hom/GroupAction.lean

tactic: rw [comp_apply, id_apply]
state_before: M' : Type ?u.269528
X : Type ?u.269531
inst✝²³ : SMul M' X
Y : Type ?u.269538
inst✝²² : SMul M' Y
Z : Type ?u.269545
inst✝²¹ : SMul M' Z
M : Type u_1
inst✝²⁰ : Monoid M
A : Type ?u.269558
inst✝¹⁹ : AddMonoid A
inst✝¹⁸ : DistribMulAction M A
A' : Type ?u.269586
inst✝¹⁷ : AddGroup A'
inst✝¹⁶ : DistribMulAction M A'
B : Type ?u.269862
inst✝¹⁵ : AddMonoid B
inst✝¹⁴ : DistribMulAction M B
B' : Type ?u.269888
inst✝¹³ : AddGroup B'
inst✝¹² : DistribMulAction M B'
C : Type ?u.270164
inst✝¹¹ : AddMonoid C
inst✝¹⁰ : DistribMulAction M C
R : Type u_2
inst✝⁹ : Semiring R
inst✝⁸ : MulSemiringAction M R
R' : Type ?u.270217
inst✝⁷ : Ring R'
inst✝⁶ : MulSemiringAction M R'
S : Type u_3
inst✝⁵ : Semiring S
inst✝⁴ : MulSemiringAction M S
S' : Type ?u.270440
inst✝³ : Ring S'
inst✝² : MulSemiringAction M S'
T : Type ?u.270636
inst✝¹ : Semiring T
inst✝ : MulSemiringAction M T
f : R →+*[M] S
x : R
⊢ ↑(comp f (MulSemiringActionHom.id M)) x = ↑f x
Theorem: GroupTopology.toTopologicalSpace_injective
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: cases f
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
f g : GroupTopology α
h : f.toTopologicalSpace = g.toTopologicalSpace
⊢ f = g

tactic: cases g
state_before: case mk
α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
g : GroupTopology α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace =
    g.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ } = g

tactic: congr
state_before: case mk.mk
α : Type u
β : Type v
G : Type w
H : Type x
inst✝ : Group α
toTopologicalSpace✝¹ : TopologicalSpace α
toTopologicalGroup✝¹ : TopologicalGroup α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ }.toTopologicalSpace =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ } =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }
Theorem: CategoryTheory.Sieve.pullback_inter
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp [Sieve.ext_iff]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
f : Y ⟶ X
S R : Sieve X
⊢ pullback f (S ⊓ R) = pullback f S ⊓ pullback f R
Theorem: continuous_of_continuousAt_one₂
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: refine ((tendsto_const_nhds.mul ((hr y).comp tendsto_fst)).mul
  (((hl x).comp tendsto_snd).mul hf)).mono_right (le_of_eq ?_)
state_before: α : Type u
β : Type v
G : Type w
H✝ : Type x
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : TopologicalSpace α
f✝ : α → G
s : Set α
x✝¹ : α
H : Type u_1
M : Type u_2
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
inst✝³ : ContinuousMul M
inst✝² : Group H
inst✝¹ : TopologicalSpace H
inst✝ : TopologicalGroup H
f : G →* H →* M
hl : ∀ (x : G), Tendsto (↑(↑f x)) (𝓝 1) (𝓝 (↑(↑f x) 1))
hr : ∀ (y : H), Tendsto (fun x => ↑(↑f x) y) (𝓝 1) (𝓝 (↑(↑f 1) y))
x✝ : G × H
x : G
y : H
hf : Tendsto (fun x => ↑(↑f x.fst) x.snd) (𝓝 1 ×ˢ 𝓝 1) (𝓝 (↑(↑f 1) 1))
⊢ Tendsto (fun x_1 => ↑(↑f x) y * ↑(↑f x_1.fst) y * (↑(↑f x) x_1.snd * ↑(↑f x_1.fst) x_1.snd)) (𝓝 1 ×ˢ 𝓝 1)
    (𝓝 (↑(↑f x) y))

tactic: simp only [map_one, mul_one, MonoidHom.one_apply]
state_before: α : Type u
β : Type v
G : Type w
H✝ : Type x
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : TopologicalSpace α
f✝ : α → G
s : Set α
x✝¹ : α
H : Type u_1
M : Type u_2
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
inst✝³ : ContinuousMul M
inst✝² : Group H
inst✝¹ : TopologicalSpace H
inst✝ : TopologicalGroup H
f : G →* H →* M
hl : ∀ (x : G), Tendsto (↑(↑f x)) (𝓝 1) (𝓝 (↑(↑f x) 1))
hr : ∀ (y : H), Tendsto (fun x => ↑(↑f x) y) (𝓝 1) (𝓝 (↑(↑f 1) y))
x✝ : G × H
x : G
y : H
hf : Tendsto (fun x => ↑(↑f x.fst) x.snd) (𝓝 1 ×ˢ 𝓝 1) (𝓝 (↑(↑f 1) 1))
⊢ 𝓝 (↑(↑f x) y * ↑(↑f 1) y * (↑(↑f x) 1 * ↑(↑f 1) 1)) = 𝓝 (↑(↑f x) y)
Theorem: Nat.sub_le_succ_sub
File: src/lean/Init/Data/Nat/Basic.lean

tactic: cases i with
| zero => apply Nat.le_of_lt; apply Nat.lt_succ_self
| succ i => rw [Nat.sub_succ, Nat.succ_sub_succ]; apply Nat.pred_le
state_before: a i : Nat
⊢ a - i ≤ succ a - i

tactic: apply Nat.le_of_lt
state_before: case zero
a : Nat
⊢ a - zero ≤ succ a - zero

tactic: apply Nat.lt_succ_self
state_before: case zero.h
a : Nat
⊢ a - zero < succ a - zero

tactic: rw [Nat.sub_succ, Nat.succ_sub_succ]
state_before: case succ
a i : Nat
⊢ a - succ i ≤ succ a - succ i

tactic: apply Nat.pred_le
state_before: case succ
a i : Nat
⊢ pred (a - i) ≤ a - i
Theorem: PerfectClosure.eq_pthRoot
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rcases x with ⟨m, x⟩
state_before: K : Type u
inst✝² : Field K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ × K
⊢ mk K p x = (↑(pthRoot (PerfectClosure K p) p)^[x.fst]) (↑(of K p) x.snd)

tactic: induction' m with m ih
state_before: case mk
K : Type u
inst✝² : Field K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
m : ℕ
x : K
⊢ mk K p (m, x) = (↑(pthRoot (PerfectClosure K p) p)^[(m, x).fst]) (↑(of K p) (m, x).snd)

tactic: rw [iterate_succ_apply', ← ih]
state_before: case mk.succ
K : Type u
inst✝² : Field K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
m : ℕ
ih : mk K p (m, x) = (↑(pthRoot (PerfectClosure K p) p)^[(m, x).fst]) (↑(of K p) (m, x).snd)
⊢ mk K p (Nat.succ m, x) = (↑(pthRoot (PerfectClosure K p) p)^[(Nat.succ m, x).fst]) (↑(of K p) (Nat.succ m, x).snd)

tactic: rfl
state_before: case mk.succ
K : Type u
inst✝² : Field K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
m : ℕ
ih : mk K p (m, x) = (↑(pthRoot (PerfectClosure K p) p)^[(m, x).fst]) (↑(of K p) (m, x).snd)
⊢ mk K p (Nat.succ m, x) = ↑(pthRoot (PerfectClosure K p) p) (mk K p (m, x))

tactic: rfl
state_before: case mk.zero
K : Type u
inst✝² : Field K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
⊢ mk K p (Nat.zero, x) = (↑(pthRoot (PerfectClosure K p) p)^[(Nat.zero, x).fst]) (↑(of K p) (Nat.zero, x).snd)
Theorem: NNReal.inv_le
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← mul_le_mul_left (pos_iff_ne_zero.2 h), mul_inv_cancel h]
state_before: r p : ℝ≥0
h : r ≠ 0
⊢ r⁻¹ ≤ p ↔ 1 ≤ r * p
Theorem: SimpleGraph.Walk.darts_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, Sym2.eq_swap]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ darts (reverse p) = List.reverse (List.map Dart.symm (darts p))
Theorem: Basis.toDual_eq_equivFun
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [b.equivFun_apply, toDual_eq_repr]
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : Fintype ι
m : M
i : ι
⊢ ↑(↑(toDual b) m) (↑b i) = ↑(equivFun b) m i
Theorem: HolorIndex.cast_type
File: Mathlib/Data/Holor.lean

tactic: subst eq
state_before: ds₁ ds₂ ds₃ is : List ℕ
eq : ds₁ = ds₂
h : Forall₂ (fun x x_1 => x < x_1) is ds₁
⊢ ↑(cast (_ : HolorIndex ds₁ = HolorIndex ds₂) { val := is, property := h }) = is

tactic: rfl
state_before: ds₁ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is ds₁
⊢ ↑(cast (_ : HolorIndex ds₁ = HolorIndex ds₁) { val := is, property := h }) = is
Theorem: StrictConcaveOn.ae_eq_const_or_lt_map_average
File: Mathlib/Analysis/Convex/Integral.lean

tactic: simpa only [Pi.neg_apply, average_neg, neg_lt_neg_iff] using
  hg.neg.ae_eq_const_or_map_average_lt hgc.neg hsc hfs hfi hgi.neg
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2320470
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : IsFiniteMeasure μ
hg : StrictConcaveOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f
hgi : Integrable (g ∘ f)
⊢ f =ᶠ[ae μ] const α (⨍ (x : α), f x ∂μ) ∨ (⨍ (x : α), g (f x) ∂μ) < g (⨍ (x : α), f x ∂μ)
Theorem: WithZeroTopology.nhds_of_ne_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [nhds_eq_update, update_noteq h₀]
state_before: α : Type ?u.27734
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ✝ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
γ : Γ₀
h₀ : γ ≠ 0
⊢ 𝓝 γ = pure γ
Theorem: ENNReal.sub_iInf
File: Mathlib/Data/Real/ENNReal.lean

tactic: refine' eq_of_forall_ge_iff fun c => _
state_before: α : Type ?u.847795
β : Type ?u.847798
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
⊢ (a - ⨅ (i : ι), f i) = ⨆ (i : ι), a - f i

tactic: rw [tsub_le_iff_right, add_comm, iInf_add]
state_before: α : Type ?u.847795
β : Type ?u.847798
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
c : ℝ≥0∞
⊢ (a - ⨅ (i : ι), f i) ≤ c ↔ (⨆ (i : ι), a - f i) ≤ c

tactic: simp [tsub_le_iff_right, sub_eq_add_neg, add_comm]
state_before: α : Type ?u.847795
β : Type ?u.847798
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
c : ℝ≥0∞
⊢ (a ≤ ⨅ (i : ι), f i + c) ↔ (⨆ (i : ι), a - f i) ≤ c
Theorem: Subgroup.characteristic_iff_le_map
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp_rw [map_equiv_eq_comap_symm]
state_before: G : Type u_1
G' : Type ?u.354562
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.354571
inst✝ : AddGroup A
H K : Subgroup G
⊢ Characteristic H ↔ ∀ (ϕ : G ≃* G), H ≤ map (MulEquiv.toMonoidHom ϕ) H

tactic: exact characteristic_iff_le_comap.trans ⟨fun h ϕ => h ϕ.symm, fun h ϕ => h ϕ.symm⟩
state_before: G : Type u_1
G' : Type ?u.354562
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.354571
inst✝ : AddGroup A
H K : Subgroup G
⊢ Characteristic H ↔ ∀ (ϕ : G ≃* G), H ≤ comap (MulEquiv.toMonoidHom (MulEquiv.symm ϕ)) H
Theorem: List.getI_eq_iget_get?
File: Mathlib/Data/List/Basic.lean

tactic: rw [← getD_default_eq_getI, getD_eq_getD_get?, Option.getD_default_eq_iget]
state_before: ι : Type ?u.507203
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
l : List α
x : α
xs : List α
n✝ n : ℕ
⊢ getI l n = Option.iget (get? l n)
Theorem: MeasureTheory.ae_lt_top'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rwa [← lintegral_congr_ae hf.ae_eq_mk]
state_before: α : Type u_1
β : Type ?u.1746227
γ : Type ?u.1746230
δ : Type ?u.1746233
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
⊢ (∫⁻ (x : α), AEMeasurable.mk f hf x ∂μ) ≠ ⊤

tactic: rwa [hx]
state_before: α : Type u_1
β : Type ?u.1746227
γ : Type ?u.1746230
δ : Type ?u.1746233
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
h2f : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h2f_meas : (∫⁻ (x : α), AEMeasurable.mk f hf x ∂μ) ≠ ⊤
x : α
hx : f x = AEMeasurable.mk f hf x
h : AEMeasurable.mk f hf x < ⊤
⊢ f x < ⊤
Theorem: frontier_eq_closure_inter_closure
File: Mathlib/Topology/Basic.lean

tactic: rw [closure_compl, frontier, diff_eq]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ frontier s = closure s ∩ closure (sᶜ)
Theorem: isValidChar_UInt32
File: src/lean/Init/Prelude.lean

tactic: decide
state_before: n : Nat
h✝ : Nat.isValidChar n
h : LT.lt n 55296
⊢ LT.lt 55296 UInt32.size

tactic: decide
state_before: n : Nat
h✝ : Nat.isValidChar n
left✝ : LT.lt 57343 n
h : LT.lt n 1114112
⊢ LT.lt 1114112 UInt32.size