1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LSeriesSummable.isBigO_rpow
File: Mathlib/NumberTheory/LSeries/Basic.lean

tactic: obtain ⟨C, hC⟩ := h.le_const_mul_rpow
state_before: f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
⊢ f =O[atTop] fun n => ↑n ^ s.re
state_after: case intro
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
⊢ f =O[atTop] fun n => ↑n ^ s.re

tactic: refine Asymptotics.IsBigO.of_bound C <| eventually_atTop.mpr ⟨1, fun n hn ↦ ?_⟩
state_before: case intro
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
⊢ f =O[atTop] fun n => ↑n ^ s.re
state_after: case intro
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
n : ℕ
hn : n ≥ 1
⊢ ‖f n‖ ≤ C * ‖↑n ^ s.re‖

tactic: convert hC n (Nat.pos_iff_ne_zero.mp hn) using 2
state_before: case intro
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
n : ℕ
hn : n ≥ 1
⊢ ‖f n‖ ≤ C * ‖↑n ^ s.re‖
state_after: case h.e'_4.h.e'_6
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
n : ℕ
hn : n ≥ 1
⊢ ‖↑n ^ s.re‖ = ↑n ^ s.re

tactic: rw [Real.norm_eq_abs, Real.abs_rpow_of_nonneg n.cast_nonneg, _root_.abs_of_nonneg n.cast_nonneg]
state_before: case h.e'_4.h.e'_6
f : ℕ → ℂ
s : ℂ
h : LSeriesSummable f s
C : ℝ
hC : ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re
n : ℕ
hn : n ≥ 1
⊢ ‖↑n ^ s.re‖ = ↑n ^ s.re
state_after: no goals
Theorem: SimpleGraph.Walk.nil_iff_eq_nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w v✝ : V
h✝ : G.Adj v v✝
p✝ : G.Walk v✝ v
⊢ (cons h✝ p✝).Nil ↔ cons h✝ p✝ = nil
state_after: no goals
Theorem: EuclideanGeometry.reflection_symm
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: ext
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ (reflection s).symm = reflection s
state_after: case h
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
x✝ : P
⊢ (reflection s).symm x✝ = (reflection s) x✝

tactic: rw [← (reflection s).injective.eq_iff]
state_before: case h
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
x✝ : P
⊢ (reflection s).symm x✝ = (reflection s) x✝
state_after: case h
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
x✝ : P
⊢ (reflection s) ((reflection s).symm x✝) = (reflection s) ((reflection s) x✝)

tactic: simp
state_before: case h
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
x✝ : P
⊢ (reflection s) ((reflection s).symm x✝) = (reflection s) ((reflection s) x✝)
state_after: no goals
Theorem: Finite.exists_max
File: Mathlib/Data/Fintype/Lattice.lean

tactic: cases nonempty_fintype α
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Finite α
inst✝¹ : Nonempty α
inst✝ : LinearOrder β
f : α → β
⊢ ∃ x₀, ∀ (x : α), f x ≤ f x₀
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Finite α
inst✝¹ : Nonempty α
inst✝ : LinearOrder β
f : α → β
val✝ : Fintype α
⊢ ∃ x₀, ∀ (x : α), f x ≤ f x₀

tactic: simpa using exists_max_image univ f univ_nonempty
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Finite α
inst✝¹ : Nonempty α
inst✝ : LinearOrder β
f : α → β
val✝ : Fintype α
⊢ ∃ x₀, ∀ (x : α), f x ≤ f x₀
state_after: no goals
Theorem: LinearMap.isSymmetric_adjoint_mul_self
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: intro x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
⊢ (adjoint T * T).IsSymmetric
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x y : E
⊢ ⟪(adjoint T * T) x, y⟫_𝕜 = ⟪x, (adjoint T * T) y⟫_𝕜

tactic: simp only [mul_apply, adjoint_inner_left, adjoint_inner_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁹ : RCLike 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
T : E →ₗ[𝕜] E
x y : E
⊢ ⟪(adjoint T * T) x, y⟫_𝕜 = ⟪x, (adjoint T * T) y⟫_𝕜
state_after: no goals
Theorem: Int.bit_val
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases b
state_before: b : Bool
n : ℤ
⊢ bit b n = 2 * n + bif b then 1 else 0
state_after: case false
n : ℤ
⊢ bit false n = 2 * n + bif false then 1 else 0

case true
n : ℤ
⊢ bit true n = 2 * n + bif true then 1 else 0

tactic: apply (bit0_val n).trans (add_zero _).symm
state_before: case false
n : ℤ
⊢ bit false n = 2 * n + bif false then 1 else 0
state_after: no goals

tactic: apply bit1_val
state_before: case true
n : ℤ
⊢ bit true n = 2 * n + bif true then 1 else 0
state_after: no goals
Theorem: SeparationQuotient.lift'_mk
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [lift', dif_pos h, lift_mk]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : T0Space β
f : α → β
h : UniformContinuous f
a : α
⊢ lift' f (mk a) = f a
state_after: no goals
Theorem: IsIntegralCurve.comp_mul
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

tactic: rw [isIntegralCurve_iff_isIntegralCurveOn] at *
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurve γ v
a : ℝ
⊢ IsIntegralCurve (γ ∘ fun x => x * a) (a • v)
state_after: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
a : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x * a) (a • v) univ

tactic: exact hγ.comp_mul _
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
hγ : IsIntegralCurveOn γ v univ
a : ℝ
⊢ IsIntegralCurveOn (γ ∘ fun x => x * a) (a • v) univ
state_after: no goals
Theorem: Ideal.span_singleton_prime
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: simp [isPrime_iff, Prime, span_singleton_eq_top, hp, mem_span_singleton]
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
p : α
hp : p ≠ 0
⊢ (span {p}).IsPrime ↔ Prime p
state_after: no goals
Theorem: Behrend.three_le_nValue
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: rw [nValue, ← lt_iff_add_one_le, lt_ceil, cast_two]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 3 ≤ nValue N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 < √(log ↑N)

tactic: apply lt_sqrt_of_sq_lt
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 < √(log ↑N)
state_after: case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ 2 < log ↑N

tactic: have : (2 : ℝ) ^ ((6 : ℕ) : ℝ) ≤ N := by
  rw [rpow_natCast]
  exact (cast_le.2 hN).trans' (by norm_num1)
state_before: case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ 2 < log ↑N
state_after: case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 < log ↑N

tactic: apply lt_of_lt_of_le _ (log_le_log (rpow_pos_of_pos zero_lt_two _) this)
state_before: case h
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 < log ↑N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 < log (2 ^ ↑6)

tactic: rw [log_rpow zero_lt_two, ← div_lt_iff']
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 < log (2 ^ ↑6)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 / ↑6 < log 2

α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 0 < ↑6

tactic: rw [rpow_natCast]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ ↑6 ≤ ↑N
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ 6 ≤ ↑N

tactic: exact (cast_le.2 hN).trans' (by norm_num1)
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ 6 ≤ ↑N
state_after: no goals

tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
⊢ 2 ^ 6 ≤ ↑64
state_after: no goals

tactic: exact log_two_gt_d9.trans_le' (by norm_num1)
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 / ↑6 < log 2
state_after: no goals

tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 2 ^ 2 / ↑6 ≤ 0.6931471803
state_after: no goals

tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 64 ≤ N
this : 2 ^ ↑6 ≤ ↑N
⊢ 0 < ↑6
state_after: no goals
Theorem: Complex.logTaylor_succ
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: funext
state_before: n : ℕ
⊢ logTaylor (n + 1) = logTaylor n + fun z => (-1) ^ (n + 1) * z ^ n / ↑n
state_after: case h
n : ℕ
x✝ : ℂ
⊢ logTaylor (n + 1) x✝ = (logTaylor n + fun z => (-1) ^ (n + 1) * z ^ n / ↑n) x✝

tactic: simpa only [logTaylor] using Finset.sum_range_succ ..
state_before: case h
n : ℕ
x✝ : ℂ
⊢ logTaylor (n + 1) x✝ = (logTaylor n + fun z => (-1) ^ (n + 1) * z ^ n / ↑n) x✝
state_after: no goals
Theorem: HahnSeries.order_C
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

tactic: by_cases h : r = 0
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
⊢ (C r).order = 0
state_after: case pos
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : r = 0
⊢ (C r).order = 0

case neg
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : ¬r = 0
⊢ (C r).order = 0

tactic: rw [h, C_zero, order_zero]
state_before: case pos
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : r = 0
⊢ (C r).order = 0
state_after: no goals

tactic: exact order_single h
state_before: case neg
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonAssocSemiring R
r : R
h : ¬r = 0
⊢ (C r).order = 0
state_after: no goals
Theorem: Vector.mapAccumr_mapAccumr
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs using Vector.revInductionOn generalizing s₁ s₂ <;> simp_all
state_before: α : Type u_3
n : ℕ
β : Type u_2
σ₁ : Type
γ : Type u_1
σ₂ : Type
xs : Vector α n
f₁ : β → σ₁ → σ₁ × γ
f₂ : α → σ₂ → σ₂ × β
s₂ : σ₂
s₁ : σ₁
⊢ mapAccumr f₁ (mapAccumr f₂ xs s₂).2 s₁ =
    let m :=
      mapAccumr
        (fun x s =>
          let r₂ := f₂ x s.2;
          let r₁ := f₁ r₂.2 s.1;
          ((r₁.1, r₂.1), r₁.2))
        xs (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals
Theorem: CategoryTheory.Limits.coequalizer.isoTargetOfSelf_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ f ≫ 𝟙 Y = f ≫ 𝟙 Y
state_after: no goals

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ (isoTargetOfSelf f).hom = desc (𝟙 Y) ⋯
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ π f f ≫ (isoTargetOfSelf f).hom = π f f ≫ desc (𝟙 Y) ⋯

tactic: simp [coequalizer.isoTargetOfSelf]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
⊢ π f f ≫ (isoTargetOfSelf f).hom = π f f ≫ desc (𝟙 Y) ⋯
state_after: no goals
Theorem: Real.sqrt_inv
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [Real.sqrt, Real.toNNReal_inv, NNReal.sqrt_inv, NNReal.coe_inv, Real.sqrt]
state_before: x✝ y x : ℝ
⊢ √x⁻¹ = (√x)⁻¹
state_after: no goals
Theorem: Stream'.get_odd
File: Mathlib/Data/Stream/Init.lean

tactic: rw [odd_eq, get_even]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ s.odd.get n = s.get (2 * n + 1)
state_after: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ s.tail.get (2 * n) = s.get (2 * n + 1)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s : Stream' α
⊢ s.tail.get (2 * n) = s.get (2 * n + 1)
state_after: no goals
Theorem: wellFounded_iff_wellFounded_subrel
File: Mathlib/Order/InitialSeg.lean

tactic: refine
  ⟨fun wf b => ⟨fun b' => ((PrincipalSeg.ofElement _ b).acc b').mpr (wf.apply b')⟩, fun wf =>
    ⟨fun b => Acc.intro _ fun b' hb' => ?_⟩⟩
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
⊢ WellFounded s ↔ ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
⊢ Acc s b'

tactic: let f := PrincipalSeg.ofElement s b
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
⊢ Acc s b'
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
⊢ Acc s b'

tactic: obtain ⟨b', rfl⟩ := f.down.mp ((PrincipalSeg.ofElement_top s b).symm ▸ hb' : s b' f.top)
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
⊢ Acc s b'
state_after: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b : β
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
b' : ↑{b_1 | s b_1 b}
hb' : s (f.toRelEmbedding b') b
⊢ Acc s (f.toRelEmbedding b')

tactic: exact (f.acc b').mp ((wf b).apply b')
state_before: case intro
α : Type u_1
β✝ : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_4
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b : β
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
b' : ↑{b_1 | s b_1 b}
hb' : s (f.toRelEmbedding b') b
⊢ Acc s (f.toRelEmbedding b')
state_after: no goals
Theorem: Nat.factors_chain
File: Mathlib/Data/Nat/Factors.lean

tactic: match n with
| 0 => simp
| 1 => simp
| k + 2 =>
    intro a h
    let m := minFac (k + 2)
    have : (k + 2) / m < (k + 2) := factors_lemma
    rw [factors]
    refine List.Chain.cons ((le_minFac.2 h).resolve_left (by simp)) (factors_chain ?_)
    exact fun p pp d => minFac_le_of_dvd pp.two_le (d.trans <| div_dvd_of_dvd <| minFac_dvd _)
state_before: n : ℕ
⊢ ∀ {a : ℕ}, (∀ (p : ℕ), Prime p → p ∣ n → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a n.factors
state_after: no goals

tactic: simp
state_before: n : ℕ
⊢ ∀ {a : ℕ}, (∀ (p : ℕ), Prime p → p ∣ 0 → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a (factors 0)
state_after: no goals

tactic: simp
state_before: n : ℕ
⊢ ∀ {a : ℕ}, (∀ (p : ℕ), Prime p → p ∣ 1 → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a (factors 1)
state_after: no goals

tactic: intro a h
state_before: n k : ℕ
⊢ ∀ {a : ℕ}, (∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors
state_after: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors

tactic: let m := minFac (k + 2)
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors
state_after: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors

tactic: have : (k + 2) / m < (k + 2) := factors_lemma
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors
state_after: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors

tactic: rw [factors]
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ List.Chain (fun x x_1 => x ≤ x_1) a (k + 2).factors
state_after: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ List.Chain (fun x x_1 => x ≤ x_1) a ((k + 2).minFac :: ((k + 2) / (k + 2).minFac).factors)

tactic: refine List.Chain.cons ((le_minFac.2 h).resolve_left (by simp)) (factors_chain ?_)
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ List.Chain (fun x x_1 => x ≤ x_1) a ((k + 2).minFac :: ((k + 2) / (k + 2).minFac).factors)
state_after: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ ∀ (p : ℕ), Prime p → p ∣ (k + 2) / (k + 2).minFac → (k + 2).minFac ≤ p

tactic: exact fun p pp d => minFac_le_of_dvd pp.two_le (d.trans <| div_dvd_of_dvd <| minFac_dvd _)
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ ∀ (p : ℕ), Prime p → p ∣ (k + 2) / (k + 2).minFac → (k + 2).minFac ≤ p
state_after: no goals

tactic: simp
state_before: n k a : ℕ
h : ∀ (p : ℕ), Prime p → p ∣ k + 2 → a ≤ p
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ ¬k + 2 = 1
state_after: no goals
Theorem: Complex.nhdsWithin_lt_le_nhdsWithin_stolzSet
File: Mathlib/Analysis/Complex/AbelLimit.lean

tactic: rw [← tendsto_id']
state_before: M : ℝ
hM : 1 < M
⊢ Filter.map ofReal' (𝓝[<] 1) ≤ 𝓝[stolzSet M] 1
state_after: M : ℝ
hM : 1 < M
⊢ Tendsto id (Filter.map ofReal' (𝓝[<] 1)) (𝓝[stolzSet M] 1)

tactic: refine tendsto_map' <| tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within ofReal'
  (tendsto_nhdsWithin_of_tendsto_nhds <| ofRealCLM.continuous.tendsto' 1 1 rfl) ?_
state_before: M : ℝ
hM : 1 < M
⊢ Tendsto id (Filter.map ofReal' (𝓝[<] 1)) (𝓝[stolzSet M] 1)
state_after: M : ℝ
hM : 1 < M
⊢ ∀ᶠ (x : ℝ) in 𝓝[<] 1, ↑x ∈ stolzSet M

tactic: simp only [eventually_iff, norm_eq_abs, abs_ofReal, abs_lt, mem_nhdsWithin]
state_before: M : ℝ
hM : 1 < M
⊢ ∀ᶠ (x : ℝ) in 𝓝[<] 1, ↑x ∈ stolzSet M
state_after: M : ℝ
hM : 1 < M
⊢ ∃ u, IsOpen u ∧ 1 ∈ u ∧ u ∩ Set.Iio 1 ⊆ {x | ↑x ∈ stolzSet M}

tactic: refine ⟨Set.Ioo 0 2, isOpen_Ioo, by norm_num, fun x hx ↦ ?_⟩
state_before: M : ℝ
hM : 1 < M
⊢ ∃ u, IsOpen u ∧ 1 ∈ u ∧ u ∩ Set.Iio 1 ⊆ {x | ↑x ∈ stolzSet M}
state_after: M : ℝ
hM : 1 < M
x : ℝ
hx : x ∈ Set.Ioo 0 2 ∩ Set.Iio 1
⊢ x ∈ {x | ↑x ∈ stolzSet M}

tactic: simp only [Set.mem_inter_iff, Set.mem_Ioo, Set.mem_Iio] at hx
state_before: M : ℝ
hM : 1 < M
x : ℝ
hx : x ∈ Set.Ioo 0 2 ∩ Set.Iio 1
⊢ x ∈ {x | ↑x ∈ stolzSet M}
state_after: M : ℝ
hM : 1 < M
x : ℝ
hx : (0 < x ∧ x < 2) ∧ x < 1
⊢ x ∈ {x | ↑x ∈ stolzSet M}

tactic: simp only [Set.mem_setOf_eq, stolzSet, ← ofReal_one, ← ofReal_sub, norm_eq_abs, abs_ofReal,
  abs_of_pos hx.1.1, abs_of_pos <| sub_pos.mpr hx.2]
state_before: M : ℝ
hM : 1 < M
x : ℝ
hx : (0 < x ∧ x < 2) ∧ x < 1
⊢ x ∈ {x | ↑x ∈ stolzSet M}
state_after: M : ℝ
hM : 1 < M
x : ℝ
hx : (0 < x ∧ x < 2) ∧ x < 1
⊢ x < 1 ∧ 1 - x < M * (1 - x)

tactic: exact ⟨hx.2, lt_mul_left (sub_pos.mpr hx.2) hM⟩
state_before: M : ℝ
hM : 1 < M
x : ℝ
hx : (0 < x ∧ x < 2) ∧ x < 1
⊢ x < 1 ∧ 1 - x < M * (1 - x)
state_after: no goals

tactic: norm_num
state_before: M : ℝ
hM : 1 < M
⊢ 1 ∈ Set.Ioo 0 2
state_after: no goals
Theorem: Set.prod_image_seq_comm
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← prod_eq_seq, ← image_swap_prod, prod_eq_seq, image_seq, ← image_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : Set β
⊢ (Prod.mk '' s).seq t = ((fun b a => (a, b)) '' t).seq s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : Set β
⊢ ((fun x => Prod.swap ∘ x) ∘ Prod.mk '' t).seq s = ((fun b a => (a, b)) '' t).seq s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : Set β
⊢ ((fun x => Prod.swap ∘ x) ∘ Prod.mk '' t).seq s = ((fun b a => (a, b)) '' t).seq s
state_after: no goals
Theorem: SimpleGraph.singletonSubgraph_snd_le_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v : V
h : G.Adj u v
⊢ G.singletonSubgraph v ≤ G.subgraphOfAdj h
state_after: no goals