1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.ceil_add_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← not_lt, ← not_lt, not_iff_not, lt_ceil]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ⌈a + ↑n⌉₊ ≤ b ↔ ⌈a⌉₊ + n ≤ b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

tactic: obtain hb | hb := le_or_lt n b
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : n ≤ b
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : b < n
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

tactic: obtain ⟨d, rfl⟩ := exists_add_of_le hb
state_before: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : n ≤ b
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
state_after: case inl.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n d : ℕ
hb : n ≤ n + d
⊢ ↑(n + d) < a + ↑n ↔ n + d < ⌈a⌉₊ + n

tactic: rw [Nat.cast_add, add_comm n, add_comm (n : α), add_lt_add_iff_right, add_lt_add_iff_right,
  lt_ceil]
state_before: case inl.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n d : ℕ
hb : n ≤ n + d
⊢ ↑(n + d) < a + ↑n ↔ n + d < ⌈a⌉₊ + n
state_after: no goals

tactic: exact iff_of_true (lt_add_of_nonneg_of_lt ha <| cast_lt.2 hb) (Nat.lt_add_left _ hb)
state_before: case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : b < n
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
state_after: no goals
Theorem: FractionalIdeal.map_one_div
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: rw [map_div, map_one]
state_before: R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁶ : CommRing R₁
K : Type u_4
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) (1 / I) = 1 / map (↑h) I
state_after: no goals
Theorem: Rat.cast_neg
File: Mathlib/Data/Rat/Cast/Defs.lean

tactic: simp [cast_def, neg_div]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q✝ q : ℚ
⊢ ↑(-q) = -↑q
state_after: no goals
Theorem: hasFDerivAt_ring_inverse
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: simpa [hasFDerivAt_iff_isLittleO_nhds_zero] using this
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
R : Type u_6
inst✝² : NormedRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
x : Rˣ
this : (fun t => Ring.inverse (↑x + t) - ↑x⁻¹ + ↑x⁻¹ * t * ↑x⁻¹) =o[𝓝 0] _root_.id
⊢ HasFDerivAt Ring.inverse (-((mulLeftRight 𝕜 R) ↑x⁻¹) ↑x⁻¹) ↑x
state_after: no goals
Theorem: Polynomial.card_support_eraseLead_add_one
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: set c := f.support.card with hc
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
⊢ f.eraseLead.support.card + 1 = f.support.card
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
⊢ f.eraseLead.support.card + 1 = c

tactic: cases h₁ : c
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
⊢ f.eraseLead.support.card + 1 = c
state_after: case zero
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
h₁ : c = 0
⊢ f.eraseLead.support.card + 1 = 0

case succ
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ f.eraseLead.support.card + 1 = n✝ + 1

tactic: case zero =>
  by_contra
  exact h (card_support_eq_zero.mp h₁)
state_before: case zero
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
h₁ : c = 0
⊢ f.eraseLead.support.card + 1 = 0

case succ
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ f.eraseLead.support.card + 1 = n✝ + 1
state_after: case succ
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ f.eraseLead.support.card + 1 = n✝ + 1

tactic: case succ =>
  rw [eraseLead_support, card_erase_of_mem (natDegree_mem_support_of_nonzero h), ← hc, h₁]
  rfl
state_before: case succ
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ f.eraseLead.support.card + 1 = n✝ + 1
state_after: no goals

tactic: by_contra
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
h₁ : c = 0
⊢ f.eraseLead.support.card + 1 = 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
h₁ : c = 0
x✝ : ¬f.eraseLead.support.card + 1 = 0
⊢ False

tactic: exact h (card_support_eq_zero.mp h₁)
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
h₁ : c = 0
x✝ : ¬f.eraseLead.support.card + 1 = 0
⊢ False
state_after: no goals

tactic: rw [eraseLead_support, card_erase_of_mem (natDegree_mem_support_of_nonzero h), ← hc, h₁]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ f.eraseLead.support.card + 1 = n✝ + 1
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ n✝ + 1 - 1 + 1 = n✝ + 1

tactic: rfl
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f ≠ 0
c : ℕ := f.support.card
hc : c = f.support.card
n✝ : ℕ
h₁ : c = n✝ + 1
⊢ n✝ + 1 - 1 + 1 = n✝ + 1
state_after: no goals
Theorem: Asymptotics.IsLittleO.symm
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [neg_sub] using h.neg_left
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ f₃ : α → E'
h : (fun x => f₁ x - f₂ x) =o[l] g
⊢ (fun x => f₂ x - f₁ x) =o[l] g
state_after: no goals
Theorem: Polynomial.natDegree_mul_C_eq_of_mul_eq_one
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

tactic: nth_rw 1 [← mul_one p]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
ai : R
au : a * ai = 1
⊢ p.natDegree = (p * 1).natDegree
state_after: no goals

tactic: rw [← C_1, ← au, RingHom.map_mul, ← mul_assoc]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
ai : R
au : a * ai = 1
⊢ (p * 1).natDegree = (p * C a * C ai).natDegree
state_after: no goals
Theorem: RightOrdContinuous.id
File: Mathlib/Order/OrdContinuous.lean

tactic: simpa only [image_id] using h
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
s : Set α
x : α
h : IsGLB s x
⊢ IsGLB (id '' s) (id x)
state_after: no goals
Theorem: SetTheory.PGame.nim_def
File: Mathlib/SetTheory/Game/Nim.lean

tactic: rw [nim]
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  nim o =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
state_after: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  (mk (Quotient.out o).α (Quotient.out o).α
      (fun o₂ =>
        let_fun x := ⋯;
        nim (typein (Quotient.out o).r o₂))
      fun o₂ =>
      let_fun x := ⋯;
      nim (typein (Quotient.out o).r o₂)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)

tactic: rfl
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  (mk (Quotient.out o).α (Quotient.out o).α
      (fun o₂ =>
        let_fun x := ⋯;
        nim (typein (Quotient.out o).r o₂))
      fun o₂ =>
      let_fun x := ⋯;
      nim (typein (Quotient.out o).r o₂)) =
    mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
      nim (typein (fun x x_1 => x < x_1) o₂)
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.has_decomp_connected_components_aux_conn
File: Mathlib/CategoryTheory/Galois/Decomposition.lean

tactic: refine ⟨Unit, fun _ ↦ X, fun _ ↦ 𝟙 X, mkCofanColimit _ (fun s ↦ s.inj ()), ?_⟩
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
X : C
inst✝ : IsConnected X
⊢ ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
X : C
inst✝ : IsConnected X
⊢ (∀ (i : Unit), IsConnected ((fun x => X) i)) ∧ Finite Unit

tactic: exact ⟨fun _ ↦ inferInstance, inferInstance⟩
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
X : C
inst✝ : IsConnected X
⊢ (∀ (i : Unit), IsConnected ((fun x => X) i)) ∧ Finite Unit
state_after: no goals
Theorem: PosNum.cast_add
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat, add_to_nat, Nat.cast_add, cast_to_nat, cast_to_nat]
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
m n : PosNum
⊢ ↑(m + n) = ↑m + ↑n
state_after: no goals
Theorem: LipschitzWith.of_edist_le
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simp only [ENNReal.coe_one, one_mul, h]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x✝ y✝ : α
r : ℝ≥0∞
h : ∀ (x y : α), edist (f x) (f y) ≤ edist x y
x y : α
⊢ edist (f x) (f y) ≤ ↑1 * edist x y
state_after: no goals
Theorem: lt_norm_sub_of_not_sameRay
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: nth_rw 1 [← sub_add_cancel x y] at h ⊢
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ x y
⊢ ‖x‖ - ‖y‖ < ‖x - y‖
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ (x - y + y) y
⊢ ‖x - y + y‖ - ‖y‖ < ‖x - y‖

tactic: exact sub_lt_iff_lt_add.2 (norm_add_lt_of_not_sameRay fun H' => h <| H'.add_left SameRay.rfl)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
h : ¬SameRay ℝ (x - y + y) y
⊢ ‖x - y + y‖ - ‖y‖ < ‖x - y‖
state_after: no goals
Theorem: tprod_eq_prod'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [tprod_eq_finprod (s.finite_toSet.subset hf), finprod_eq_prod_of_mulSupport_subset _ hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a a₁ a₂ : α
s : Finset β
hf : mulSupport f ⊆ ↑s
⊢ ∏' (b : β), f b = ∏ b ∈ s, f b
state_after: no goals
Theorem: SimpleGraph.card_neighborSet_union_compl_neighborSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: classical simp_rw [neighborSet_union_compl_neighborSet_eq, Set.toFinset_compl,
    Finset.card_compl, Set.toFinset_card, Set.card_singleton]
state_before: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
G : SimpleGraph V
v : V
inst✝ : Fintype ↑(G.neighborSet v ∪ Gᶜ.neighborSet v)
⊢ (G.neighborSet v ∪ Gᶜ.neighborSet v).toFinset.card = Fintype.card V - 1
state_after: no goals

tactic: simp_rw [neighborSet_union_compl_neighborSet_eq, Set.toFinset_compl,
Finset.card_compl, Set.toFinset_card, Set.card_singleton]
state_before: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
G : SimpleGraph V
v : V
inst✝ : Fintype ↑(G.neighborSet v ∪ Gᶜ.neighborSet v)
⊢ (G.neighborSet v ∪ Gᶜ.neighborSet v).toFinset.card = Fintype.card V - 1
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addY_of_Z_eq_zero_right
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp only [addY, addX_of_Z_eq_zero_right hQz, negAddY_of_Z_eq_zero_right hQ hQz,
  addZ_of_Z_eq_zero_right hQz, negY, fin3_def_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQ : W'.Equation Q
hQz : Q z = 0
⊢ W'.addY P Q = (-(Q x * P z)) ^ 3 * P y
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQ : W'.Equation Q
hQz : Q z = 0
⊢ -((-(Q x * P z)) ^ 3 * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3)) -
        W'.a₁ * ((-(Q x * P z)) ^ 2 * P x) * (-(Q x * P z) * P z) -
      W'.a₃ * (-(Q x * P z) * P z) ^ 3 =
    (-(Q x * P z)) ^ 3 * P y

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQ : W'.Equation Q
hQz : Q z = 0
⊢ -((-(Q x * P z)) ^ 3 * (-P y - W'.a₁ * P x * P z - W'.a₃ * P z ^ 3)) -
        W'.a₁ * ((-(Q x * P z)) ^ 2 * P x) * (-(Q x * P z) * P z) -
      W'.a₃ * (-(Q x * P z) * P z) ^ 3 =
    (-(Q x * P z)) ^ 3 * P y
state_after: no goals
Theorem: Ordnode.balancedSz_up
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: refine or_iff_not_imp_left.2 fun h => ?_
state_before: α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
H : BalancedSz l r₁
⊢ BalancedSz l r₂
state_after: α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
H : BalancedSz l r₁
h : ¬l + r₂ ≤ 1
⊢ l ≤ delta * r₂ ∧ r₂ ≤ delta * l

tactic: refine ⟨?_, h₂.resolve_left h⟩
state_before: α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
H : BalancedSz l r₁
h : ¬l + r₂ ≤ 1
⊢ l ≤ delta * r₂ ∧ r₂ ≤ delta * l
state_after: α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
H : BalancedSz l r₁
h : ¬l + r₂ ≤ 1
⊢ l ≤ delta * r₂

tactic: cases r₂
state_before: case inl
α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
h : ¬l + r₂ ≤ 1
H : l + r₁ ≤ 1
⊢ l ≤ delta * r₂
state_after: case inl.zero
α : Type u_1
l r₁ : ℕ
H : l + r₁ ≤ 1
h₁ : r₁ ≤ 0
h₂ : l + 0 ≤ 1 ∨ 0 ≤ delta * l
h : ¬l + 0 ≤ 1
⊢ l ≤ delta * 0

case inl.succ
α : Type u_1
l r₁ : ℕ
H : l + r₁ ≤ 1
n✝ : ℕ
h₁ : r₁ ≤ n✝ + 1
h₂ : l + (n✝ + 1) ≤ 1 ∨ n✝ + 1 ≤ delta * l
h : ¬l + (n✝ + 1) ≤ 1
⊢ l ≤ delta * (n✝ + 1)

tactic: cases h (le_trans (Nat.add_le_add_left (Nat.zero_le _) _) H)
state_before: case inl.zero
α : Type u_1
l r₁ : ℕ
H : l + r₁ ≤ 1
h₁ : r₁ ≤ 0
h₂ : l + 0 ≤ 1 ∨ 0 ≤ delta * l
h : ¬l + 0 ≤ 1
⊢ l ≤ delta * 0
state_after: no goals

tactic: exact le_trans (le_trans (Nat.le_add_right _ _) H) (Nat.le_add_left 1 _)
state_before: case inl.succ
α : Type u_1
l r₁ : ℕ
H : l + r₁ ≤ 1
n✝ : ℕ
h₁ : r₁ ≤ n✝ + 1
h₂ : l + (n✝ + 1) ≤ 1 ∨ n✝ + 1 ≤ delta * l
h : ¬l + (n✝ + 1) ≤ 1
⊢ l ≤ delta * (n✝ + 1)
state_after: no goals

tactic: exact le_trans H.1 (Nat.mul_le_mul_left _ h₁)
state_before: case inr
α : Type u_1
l r₁ r₂ : ℕ
h₁ : r₁ ≤ r₂
h₂ : l + r₂ ≤ 1 ∨ r₂ ≤ delta * l
h : ¬l + r₂ ≤ 1
H : l ≤ delta * r₁ ∧ r₁ ≤ delta * l
⊢ l ≤ delta * r₂
state_after: no goals
Theorem: intervalIntegral.measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab hmeas
    stronglyMeasurableAt_bot hf ((tendsto_bot : Tendsto _ ⊥ (𝓝 (0 : E))).mono_left inf_le_left) hu
    hv (tendsto_const_pure : Tendsto _ _ (pure b)) tendsto_const_pure
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f : ℝ → E
a b : ℝ
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
μ : Measure ℝ
u v ua va ub vb : ι → ℝ
inst✝³ : CompleteSpace E
inst✝² : FTCFilter a la la'
inst✝¹ : FTCFilter b lb lb'
inst✝ : IsLocallyFiniteMeasure μ
hab : IntervalIntegrable f μ a b
hmeas : StronglyMeasurableAtFilter f la' μ
hf : Tendsto f (la' ⊓ ae μ) (𝓝 c)
hu : Tendsto u lt la
hv : Tendsto v lt la
⊢ (fun t => ∫ (x : ℝ) in v t..b, f x ∂μ - ∫ (x : ℝ) in u t..b, f x ∂μ + ∫ (x : ℝ) in u t..v t, c ∂μ) =o[lt] fun t =>
    ∫ (x : ℝ) in u t..v t, 1 ∂μ
state_after: no goals
Theorem: Subsemigroup.mem_iSup_of_mem
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

tactic: have : S i ≤ iSup S := le_iSup _ _
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
state_after: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
this : S i ≤ iSup S
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S

tactic: tauto
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
this : S i ≤ iSup S
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
state_after: no goals
Theorem: padicNormE.eq_of_norm_add_lt_left
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [padicNormE.add_eq_max_of_ne hne]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z1‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖

tactic: apply le_max_left
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖
state_after: no goals
Theorem: Computation.map_congr
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← lift_eq_iff_equiv]
state_before: α : Type u
β : Type v
γ : Type w
s1 s2 : Computation α
f : α → β
h1 : s1 ~ s2
⊢ map f s1 ~ map f s2
state_after: α : Type u
β : Type v
γ : Type w
s1 s2 : Computation α
f : α → β
h1 : s1 ~ s2
⊢ LiftRel (fun x x_1 => x = x_1) (map f s1) (map f s2)

tactic: exact liftRel_map Eq _ ((lift_eq_iff_equiv _ _).2 h1) fun {a} b => congr_arg _
state_before: α : Type u
β : Type v
γ : Type w
s1 s2 : Computation α
f : α → β
h1 : s1 ~ s2
⊢ LiftRel (fun x x_1 => x = x_1) (map f s1) (map f s2)
state_after: no goals
Theorem: ENNReal.mul_left_strictMono
File: Mathlib/Data/ENNReal/Operations.lean

tactic: lift a to ℝ≥0 using hinf
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hinf : a ≠ ⊤
⊢ StrictMono fun x => a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ StrictMono fun x => ↑a * x

tactic: rw [coe_ne_zero] at h0
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ StrictMono fun x => ↑a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
⊢ StrictMono fun x => ↑a * x

tactic: intro x y h
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
⊢ StrictMono fun x => ↑a * x
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : x < y
⊢ (fun x => ↑a * x) x < (fun x => ↑a * x) y

tactic: contrapose! h
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : x < y
⊢ (fun x => ↑a * x) x < (fun x => ↑a * x) y
state_after: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : ↑a * y ≤ ↑a * x
⊢ y ≤ x

tactic: simpa only [← mul_assoc, ← coe_mul, inv_mul_cancel h0, coe_one, one_mul]
  using mul_le_mul_left' h (↑a⁻¹)
state_before: case intro
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : ↑a * y ≤ ↑a * x
⊢ y ≤ x
state_after: no goals
Theorem: div_lt_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, div_lt_iff_of_neg hc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ b / c < a ↔ c * a < b
state_after: no goals
Theorem: Finset.right_eq_union
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [eq_comm, union_eq_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ s = t ∪ s ↔ t ⊆ s
state_after: no goals