tasksource/leandojo huggingface dataset:
Theorem: List.Subperm.diff_right
File: Mathlib/Data/List/Perm.lean

tactic: induction t generalizing l₁ l₂ h <;> simp [*, Subperm.erase]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : l₁ <+~ l₂
t : List α
⊢ List.diff l₁ t <+~ List.diff l₂ t
Theorem: Set.Iio_subset_Iic_iff
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← diff_eq_empty, Iio_diff_Iic, Ioo_eq_empty_iff, not_lt]
state_before: α : Type u_1
β : Type ?u.74390
inst✝¹ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
inst✝ : DenselyOrdered α
⊢ Iio a ⊆ Iic b ↔ a ≤ b
Theorem: FirstOrder.Language.BoundedFormula.realize_liftAt_one
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp [realize_liftAt (add_le_add_right hmn 1), castSucc]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.118977
P : Type ?u.118980
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n✝ l : ℕ
φ✝ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v✝ : α → M
xs✝ : Fin l → M
n m : ℕ
φ : BoundedFormula L α n
v : α → M
xs : Fin (n + 1) → M
hmn : m ≤ n
⊢ Realize (liftAt 1 m φ) v xs ↔ Realize φ v (xs ∘ fun i => if ↑i < m then ↑castSucc i else succ i)
Theorem: MeasureTheory.Measure.measure_inter_eq_of_measure_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [h] at ht_ne_top
state_before: α : Type u_1
β : Type ?u.86486
γ : Type ?u.86489
δ : Type ?u.86492
ι : Type ?u.86495
R : Type ?u.86498
R' : Type ?u.86501
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t u : Set α
hs : MeasurableSet s
h : ↑↑μ t = ↑↑μ u
htu : t ⊆ u
ht_ne_top : ↑↑μ t ≠ ⊤
⊢ ↑↑μ (t ∩ s) = ↑↑μ (u ∩ s)

tactic: refine' le_antisymm (measure_mono (inter_subset_inter_left _ htu)) _
state_before: α : Type u_1
β : Type ?u.86486
γ : Type ?u.86489
δ : Type ?u.86492
ι : Type ?u.86495
R : Type ?u.86498
R' : Type ?u.86501
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t u : Set α
hs : MeasurableSet s
h : ↑↑μ t = ↑↑μ u
htu : t ⊆ u
ht_ne_top : ↑↑μ u ≠ ⊤
⊢ ↑↑μ (t ∩ s) = ↑↑μ (u ∩ s)

tactic: have A : μ (u ∩ s) + μ (u \ s) ≤ μ (t ∩ s) + μ (u \ s) :=
  calc
    μ (u ∩ s) + μ (u \ s) = μ u := measure_inter_add_diff _ hs
    _ = μ t := h.symm
    _ = μ (t ∩ s) + μ (t \ s) := (measure_inter_add_diff _ hs).symm
    _ ≤ μ (t ∩ s) + μ (u \ s) :=
      add_le_add le_rfl (measure_mono (diff_subset_diff htu Subset.rfl))
state_before: α : Type u_1
β : Type ?u.86486
γ : Type ?u.86489
δ : Type ?u.86492
ι : Type ?u.86495
R : Type ?u.86498
R' : Type ?u.86501
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t u : Set α
hs : MeasurableSet s
h : ↑↑μ t = ↑↑μ u
htu : t ⊆ u
ht_ne_top : ↑↑μ u ≠ ⊤
⊢ ↑↑μ (u ∩ s) ≤ ↑↑μ (t ∩ s)

tactic: have B : μ (u \ s) ≠ ∞ := (lt_of_le_of_lt (measure_mono (diff_subset _ _)) ht_ne_top.lt_top).ne
state_before: α : Type u_1
β : Type ?u.86486
γ : Type ?u.86489
δ : Type ?u.86492
ι : Type ?u.86495
R : Type ?u.86498
R' : Type ?u.86501
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t u : Set α
hs : MeasurableSet s
h : ↑↑μ t = ↑↑μ u
htu : t ⊆ u
ht_ne_top : ↑↑μ u ≠ ⊤
A : ↑↑μ (u ∩ s) + ↑↑μ (u \ s) ≤ ↑↑μ (t ∩ s) + ↑↑μ (u \ s)
⊢ ↑↑μ (u ∩ s) ≤ ↑↑μ (t ∩ s)

tactic: exact ENNReal.le_of_add_le_add_right B A
state_before: α : Type u_1
β : Type ?u.86486
γ : Type ?u.86489
δ : Type ?u.86492
ι : Type ?u.86495
R : Type ?u.86498
R' : Type ?u.86501
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t u : Set α
hs : MeasurableSet s
h : ↑↑μ t = ↑↑μ u
htu : t ⊆ u
ht_ne_top : ↑↑μ u ≠ ⊤
A : ↑↑μ (u ∩ s) + ↑↑μ (u \ s) ≤ ↑↑μ (t ∩ s) + ↑↑μ (u \ s)
B : ↑↑μ (u \ s) ≠ ⊤
⊢ ↑↑μ (u ∩ s) ≤ ↑↑μ (t ∩ s)
Theorem: Derivation.map_coe_int
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: rw [← zsmul_one, D.map_smul_of_tower n, map_one_eq_zero, smul_zero]
state_before: R : Type u_3
inst✝⁵ : CommRing R
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
M : Type u_1
inst✝² : AddCommGroup M
inst✝¹ : Module A M
inst✝ : Module R M
D D1 D2 : Derivation R A M
r : R
a b : A
n : ℤ
⊢ ↑D ↑n = 0
Theorem: ProbabilityTheory.kernel.set_integral_deterministic
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, set_integral_dirac f _ s]
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.403779
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : β → E
g : α → β
a : α
hg : Measurable g
inst✝¹ : MeasurableSingletonClass β
s : Set β
inst✝ : Decidable (g a ∈ s)
⊢ (∫ (x : β) in s, f x ∂↑(deterministic g hg) a) = if g a ∈ s then f (g a) else 0
Theorem: ENNReal.biSup_add_biSup_le'
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp_rw [biSup_add' hp, add_biSup' hq]
state_before: α : Type ?u.140110
β : Type ?u.140113
γ : Type ?u.140116
a✝ b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
q : ι' → Prop
hp : ∃ i, p i
hq : ∃ j, q j
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι), p i → ∀ (j : ι'), q j → f i + g j ≤ a
⊢ ((⨆ (i : ι) (_ : p i), f i) + ⨆ (j : ι') (_ : q j), g j) ≤ a

tactic: exact iSup₂_le fun i hi => iSup₂_le (h i hi)
state_before: α : Type ?u.140110
β : Type ?u.140113
γ : Type ?u.140116
a✝ b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
q : ι' → Prop
hp : ∃ i, p i
hq : ∃ j, q j
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι), p i → ∀ (j : ι'), q j → f i + g j ≤ a
⊢ (⨆ (i : ι) (_ : p i) (i_1 : ι') (_ : q i_1), f i + g i_1) ≤ a
Theorem: Set.image_mul_left_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: convert image_mul_right_Icc hbc ha using 1 <;> simp only [mul_comm _ a]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
ha : 0 ≤ a
hbc : b ≤ c
⊢ (fun x x_1 => x * x_1) a '' Icc b c = Icc (a * b) (a * c)
Theorem: Odd.mul
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨m, rfl⟩ ⟨n, rfl⟩
state_before: F : Type ?u.88859
α : Type u_1
β : Type ?u.88865
R : Type ?u.88868
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ Odd m → Odd n → Odd (m * n)

tactic: refine' ⟨2 * m * n + n + m, _⟩
state_before: case intro.intro
F : Type ?u.88859
α : Type u_1
β : Type ?u.88865
R : Type ?u.88868
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ Odd ((2 * m + 1) * (2 * n + 1))

tactic: rw [mul_add, add_mul, mul_one, ← add_assoc, one_mul, mul_assoc, ← mul_add, ← mul_add, ← mul_assoc,
  ← Nat.cast_two, ← Nat.cast_comm]
state_before: case intro.intro
F : Type ?u.88859
α : Type u_1
β : Type ?u.88865
R : Type ?u.88868
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
⊢ (2 * m + 1) * (2 * n + 1) = 2 * (2 * m * n + n + m) + 1
Theorem: StieltjesFunction.rightLim_eq
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: rw [← f.mono.continuousWithinAt_Ioi_iff_rightLim_eq, continuousWithinAt_Ioi_iff_Ici]
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ rightLim (↑f) x = ↑f x

tactic: exact f.right_continuous' x
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ ContinuousWithinAt (↑f) (Ici x) x
Theorem: ENNReal.inv_le_iff_le_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← one_div, ENNReal.div_le_iff_le_mul, mul_comm]
state_before: α : Type ?u.294363
β : Type ?u.294366
a b c d : ℝ≥0∞
r p q : ℝ≥0
h₁ : b = ⊤ → a ≠ 0
h₂ : a = ⊤ → b ≠ 0
⊢ a⁻¹ ≤ b ↔ 1 ≤ a * b

tactic: exacts [or_not_of_imp h₁, not_or_of_imp h₂]
state_before: case hb0
α : Type ?u.294363
β : Type ?u.294366
a b c d : ℝ≥0∞
r p q : ℝ≥0
h₁ : b = ⊤ → a ≠ 0
h₂ : a = ⊤ → b ≠ 0
⊢ a ≠ 0 ∨ b ≠ ⊤

case hbt
α : Type ?u.294363
β : Type ?u.294366
a b c d : ℝ≥0∞
r p q : ℝ≥0
h₁ : b = ⊤ → a ≠ 0
h₂ : a = ⊤ → b ≠ 0
⊢ a ≠ ⊤ ∨ b ≠ 0
Theorem: InnerProductGeometry.angle_add_eq_arccos_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, inner_add_right, h, add_zero, real_inner_self_eq_norm_mul_norm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ angle x (x + y) = Real.arccos (‖x‖ / ‖x + y‖)

tactic: by_cases hx : ‖x‖ = 0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ Real.arccos (‖x‖ * ‖x‖ / (‖x‖ * ‖x + y‖)) = Real.arccos (‖x‖ / ‖x + y‖)

tactic: rw [div_mul_eq_div_div, mul_self_div_self]
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hx : ¬‖x‖ = 0
⊢ Real.arccos (‖x‖ * ‖x‖ / (‖x‖ * ‖x + y‖)) = Real.arccos (‖x‖ / ‖x + y‖)

tactic: simp [hx]
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hx : ‖x‖ = 0
⊢ Real.arccos (‖x‖ * ‖x‖ / (‖x‖ * ‖x + y‖)) = Real.arccos (‖x‖ / ‖x + y‖)
Theorem: Filter.Tendsto.add_atTop
File: Mathlib/Topology/Order/Basic.lean

tactic: nontriviality α
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x + g x) l atTop

tactic: obtain ⟨C', hC'⟩ : ∃ C', C' < C := exists_lt C
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
✝ : Nontrivial α
⊢ Tendsto (fun x => f x + g x) l atTop

tactic: refine' tendsto_atTop_add_left_of_le' _ C' _ hg
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
✝ : Nontrivial α
C' : α
hC' : C' < C
⊢ Tendsto (fun x => f x + g x) l atTop

tactic: exact (hf.eventually (lt_mem_nhds hC')).mono fun x => le_of_lt
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
✝ : Nontrivial α
C' : α
hC' : C' < C
⊢ ∀ᶠ (x : β) in l, C' ≤ f x
Theorem: Int.ceil_sub_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [Int.cast_neg, sub_eq_add_neg]
state_before: F : Type ?u.214227
α : Type u_1
β : Type ?u.214233
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
z : ℤ
⊢ ⌈a - ↑z⌉ = ⌈a + ↑(-z)⌉
Theorem: SimpleGraph.Walk.isPath_reverse_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor <;> intro h <;> convert h.reverse
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
⊢ IsPath (reverse p) ↔ IsPath p

tactic: simp
state_before: case h.e'_5
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
h : IsPath (reverse p)
⊢ p = reverse (reverse p)
Theorem: Filter.comap_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [empty_subset, preimage_empty]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.251865
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s✝ : Set α
t : Set β
s : Set α
x✝ : s ∈ ⊥
⊢ m ⁻¹' ∅ ⊆ s
Theorem: Algebra.adjoin_toSubmodule_le
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: rw [adjoin_eq_span, span_le]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s✝ t✝ s : Set A
t : Submodule R A
⊢ ↑Subalgebra.toSubmodule (adjoin R s) ≤ t ↔ ↑(Submonoid.closure s) ⊆ ↑t
Theorem: MeasureTheory.le_lintegral_add
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [lintegral]
state_before: α : Type u_1
β : Type ?u.797130
γ : Type ?u.797133
δ : Type ?u.797136
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
⊢ ((∫⁻ (a : α), f a ∂μ) + ∫⁻ (a : α), g a ∂μ) ≤ ∫⁻ (a : α), f a + g a ∂μ

tactic: refine' ENNReal.biSup_add_biSup_le' (p := fun h : α →ₛ ℝ≥0∞ => h ≤ f)
  (q := fun h : α →ₛ ℝ≥0∞ => h ≤ g) ⟨0, zero_le f⟩ ⟨0, zero_le g⟩ fun f' hf' g' hg' => _
state_before: α : Type u_1
β : Type ?u.797130
γ : Type ?u.797133
δ : Type ?u.797136
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
⊢ ((⨆ (g : α →ₛ ℝ≥0∞) (_ : ↑g ≤ fun a => f a), SimpleFunc.lintegral g μ) +
      ⨆ (g_1 : α →ₛ ℝ≥0∞) (_ : ↑g_1 ≤ fun a => g a), SimpleFunc.lintegral g_1 μ) ≤
    ⨆ (g_1 : α →ₛ ℝ≥0∞) (_ : ↑g_1 ≤ fun a => f a + g a), SimpleFunc.lintegral g_1 μ

tactic: exact le_iSup₂_of_le (f' + g') (add_le_add hf' hg') (add_lintegral _ _).ge
state_before: α : Type u_1
β : Type ?u.797130
γ : Type ?u.797133
δ : Type ?u.797136
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
f' : α →ₛ ℝ≥0∞
hf' : (fun h => ↑h ≤ f) f'
g' : α →ₛ ℝ≥0∞
hg' : (fun h => ↑h ≤ g) g'
⊢ SimpleFunc.lintegral f' μ + SimpleFunc.lintegral g' μ ≤
    ⨆ (g_1 : α →ₛ ℝ≥0∞) (_ : ↑g_1 ≤ fun a => f a + g a), SimpleFunc.lintegral g_1 μ
Theorem: Polynomial.degree_gcd_le_right
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [gcd_comm]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ degree (gcd p q) ≤ degree q

tactic: exact degree_gcd_le_left hq p
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ degree (gcd q p) ≤ degree q
Theorem: SimpleGraph.Walk.append_nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => rw [cons_append, ih]
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
⊢ append p nil = p

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
⊢ append nil nil = nil

tactic: rw [cons_append, ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : append p✝ nil = p✝
⊢ append (cons h✝ p✝) nil = cons h✝ p✝
Theorem: NormedField.tendsto_norm_zpow_nhdsWithin_0_atTop
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rcases neg_surjective m with ⟨m, rfl⟩
state_before: α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℤ
hm : m < 0
⊢ Tendsto (fun x => ‖x ^ m‖) (𝓝[{0}ᶜ] 0) atTop

tactic: rw [neg_lt_zero] at hm
state_before: case intro
α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℤ
hm : -m < 0
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[{0}ᶜ] 0) atTop

tactic: lift m to ℕ using hm.le
state_before: case intro
α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℤ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-m)‖) (𝓝[{0}ᶜ] 0) atTop

tactic: rw [Int.coe_nat_pos] at hm
state_before: case intro.intro
α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℕ
hm : 0 < ↑m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[{0}ᶜ] 0) atTop

tactic: simp only [norm_pow, zpow_neg, zpow_ofNat, ← inv_pow]
state_before: case intro.intro
α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x ^ (-↑m)‖) (𝓝[{0}ᶜ] 0) atTop

tactic: exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
state_before: case intro.intro
α : Type ?u.55104
β : Type ?u.55107
ι : Type ?u.55110
𝕜 : Type u_1
inst✝ : NormedField 𝕜
m : ℕ
hm : 0 < m
⊢ Tendsto (fun x => ‖x⁻¹‖ ^ m) (𝓝[{0}ᶜ] 0) atTop
Theorem: RingQuot.mkAlgHom_surjective
File: Mathlib/Algebra/RingQuot.lean

tactic: suffices : Function.Surjective fun x ↦ (⟨.mk (Rel s) x⟩ : RingQuot s)
state_before: R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝ : Semiring T
s : A → A → Prop
⊢ Function.Surjective ↑(mkAlgHom S s)

tactic: rintro ⟨⟨a⟩⟩
state_before: case this
R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝ : Semiring T
s : A → A → Prop
⊢ Function.Surjective fun x => { toQuot := Quot.mk (Rel s) x }

tactic: use a
state_before: case this.mk.mk
R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝ : Semiring T
s : A → A → Prop
toQuot✝ : Quot (Rel s)
a : A
⊢ ∃ a_1, (fun x => { toQuot := Quot.mk (Rel s) x }) a_1 = { toQuot := Quot.mk (Rel s) a }

tactic: simpa  [mkAlgHom_def, mkRingHom_def]
state_before: R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝ : Semiring T
s : A → A → Prop
this : Function.Surjective fun x => { toQuot := Quot.mk (Rel s) x }
⊢ Function.Surjective ↑(mkAlgHom S s)
Theorem: Nat.mod_add_mod
File: Std/Data/Nat/Lemmas.lean

tactic: have := (add_mul_mod_self_left (m % n + k) n (m / n)).symm
state_before: m n k : Nat
⊢ (m % n + k) % n = (m + k) % n

tactic: rwa [Nat.add_right_comm, mod_add_div] at this
state_before: m n k : Nat
this : (m % n + k) % n = (m % n + k + n * (m / n)) % n
⊢ (m % n + k) % n = (m + k) % n
Theorem: Part.to_unit_cont
File: Mathlib/Control/LawfulFix.lean

tactic: ext ⟨⟩ : 1
state_before: α : Type u_1
β : α → Type ?u.16900
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ↑(toUnitMono f) (ωSup x✝) = ωSup (Chain.map x✝ (toUnitMono f))

tactic: dsimp [OmegaCompletePartialOrder.ωSup]
state_before: case h.unit
α : Type u_1
β : α → Type ?u.16900
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ↑(toUnitMono f) (ωSup x✝) PUnit.unit = ωSup (Chain.map x✝ (toUnitMono f)) PUnit.unit

tactic: erw [hc, Chain.map_comp]
state_before: case h.unit
α : Type u_1
β : α → Type ?u.16900
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ↑f (Part.ωSup (Chain.map x✝ (Pi.evalOrderHom PUnit.unit))) =
    Part.ωSup (Chain.map (Chain.map x✝ (toUnitMono f)) (Pi.evalOrderHom PUnit.unit))

tactic: rfl
state_before: case h.unit
α : Type u_1
β : α → Type ?u.16900
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ωSup (Chain.map x✝ (OrderHom.comp f (Pi.evalOrderHom PUnit.unit))) =
    Part.ωSup (Chain.map x✝ (OrderHom.comp f (Pi.evalOrderHom PUnit.unit)))
Theorem: Std.RBNode.Ordered.lowerBound?_lt
File: Std/Data/RBMap/Lemmas.lean

tactic: refine ⟨fun h => ?_, fun h => OrientedCmp.cmp_eq_gt.1 ?_⟩
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
⊢ cmp x y = Ordering.lt ↔ cut y = Ordering.lt

tactic: cases e : cut x
state_before: case refine_1
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cmp x y = Ordering.lt
⊢ cut y = Ordering.lt

tactic: cases lowerBound?_le H e
state_before: case refine_1.lt
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cmp x y = Ordering.lt
e : cut x = Ordering.lt
⊢ cut y = Ordering.lt

tactic: exact IsStrictCut.exact e |>.symm.trans h
state_before: case refine_1.eq
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cmp x y = Ordering.lt
e : cut x = Ordering.eq
⊢ cut y = Ordering.lt

tactic: exact ht.lowerBound?_least H hy h e
state_before: case refine_1.gt
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cmp x y = Ordering.lt
e : cut x = Ordering.gt
⊢ cut y = Ordering.lt

tactic: by_contra h'
state_before: case refine_2
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cut y = Ordering.lt
⊢ cmp y x = Ordering.gt

tactic: exact lowerBound?_le H <| IsCut.le_lt_trans (cmp := cmp) (cut := cut) h' h
state_before: case refine_2
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
h : cut y = Ordering.lt
h' : ¬cmp y x = Ordering.gt
⊢ False
Theorem: Ordinal.blsub_comp
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← hg]
state_before: α : Type ?u.365393
β : Type ?u.365396
γ : Type ?u.365399
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
a : Ordinal
ha : a < o'
⊢ g a ha < o

tactic: apply lt_blsub
state_before: α : Type ?u.365393
β : Type ?u.365396
γ : Type ?u.365399
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
a : Ordinal
ha : a < o'
⊢ g a ha < blsub o' g