1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Pell.Solution₁.exists_pos_of_not_isSquare
File: Mathlib/NumberTheory/Pell.lean

tactic: obtain ⟨x, y, h, hy⟩ := exists_of_not_isSquare h₀ hd
state_before: d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
⊢ ∃ a, 1 < a.x ∧ 0 < a.y
state_after: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ ∃ a, 1 < a.x ∧ 0 < a.y

tactic: refine ⟨mk |x| |y| (by rwa [sq_abs, sq_abs]), ?_, abs_pos.mpr hy⟩
state_before: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ ∃ a, 1 < a.x ∧ 0 < a.y
state_after: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ 1 < (mk |x| |y| ⋯).x

tactic: rw [x_mk, ← one_lt_sq_iff_one_lt_abs, eq_add_of_sub_eq h, lt_add_iff_pos_right]
state_before: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ 1 < (mk |x| |y| ⋯).x
state_after: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ 0 < d * y ^ 2

tactic: exact mul_pos h₀ (sq_pos_of_ne_zero hy)
state_before: case intro.intro.intro
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ 0 < d * y ^ 2
state_after: no goals

tactic: rwa [sq_abs, sq_abs]
state_before: d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
x y : ℤ
h : x ^ 2 - d * y ^ 2 = 1
hy : y ≠ 0
⊢ |x| ^ 2 - d * |y| ^ 2 = 1
state_after: no goals
Theorem: Int.card_Ioc_of_le
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_Ioc, toNat_sub_of_le h]
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(Ioc a b).card = b - a
state_after: no goals
Theorem: List.product_eq_productTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: funext α β l₁ l₂
state_before: ⊢ @product = @productTR
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ l₁.product l₂ = l₁.productTR l₂

tactic: simp [product, productTR]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ l₁.product l₂ = l₁.productTR l₂
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = (foldl (fun acc a => foldl (fun acc b => acc.push (a, b)) acc l₂) #[] l₁).data

tactic: rw [Array.foldl_data_eq_bind]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = (foldl (fun acc a => foldl (fun acc b => acc.push (a, b)) acc l₂) #[] l₁).data
state_after: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ α → List (α × β)

case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ ?h.h.h.h.G a

tactic: rfl
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ (l₁.bind fun a => map (Prod.mk a) l₂) = #[].data ++ l₁.bind ?h.h.h.h.G

case h.h.h.h.G
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ α → List (α × β)

case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ ?h.h.h.h.G a
state_after: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ map (Prod.mk a) l₂

tactic: intros
state_before: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
⊢ ∀ (acc : Array (α × β)) (a : α), (foldl (fun acc b => acc.push (a, b)) acc l₂).data = acc.data ++ map (Prod.mk a) l₂
state_after: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
acc✝ : Array (α × β)
a✝ : α
⊢ (foldl (fun acc b => acc.push (a✝, b)) acc✝ l₂).data = acc✝.data ++ map (Prod.mk a✝) l₂

tactic: apply Array.foldl_data_eq_map
state_before: case h.h.h.h.H
α : Type u_2
β : Type u_1
l₁ : List α
l₂ : List β
acc✝ : Array (α × β)
a✝ : α
⊢ (foldl (fun acc b => acc.push (a✝, b)) acc✝ l₂).data = acc✝.data ++ map (Prod.mk a✝) l₂
state_after: no goals
Theorem: Substring.ValidFor.get
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa using get_of_valid (l ++ m₁) (c :: m₂ ++ r)
state_before: l m₁ : List Char
c : Char
m₂ r : List Char
⊢ { str := { data := l ++ (m₁ ++ c :: m₂) ++ r }, startPos := { byteIdx := utf8Len l },
          stopPos := { byteIdx := utf8Len l + utf8Len (m₁ ++ c :: m₂) } }.get
      { byteIdx := utf8Len m₁ } =
    c
state_after: no goals
Theorem: Set.preimage_mul_right_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_right', image_singleton]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * a) ⁻¹' {b} = {b * a⁻¹}
state_after: no goals
Theorem: lt_inv_iff_mul_lt_one
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b < b⁻¹ * b ↔ a * b < 1
state_after: no goals
Theorem: IsOpen.polishSpace
File: Mathlib/Topology/MetricSpace/Polish.lean

tactic: letI := upgradePolishSpace α
state_before: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
⊢ PolishSpace ↑s
state_after: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s

tactic: lift s to Opens α using hs
state_before: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s
state_after: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s

tactic: have : SecondCountableTopology s.CompleteCopy := inferInstanceAs (SecondCountableTopology s)
state_before: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s
state_after: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology s.CompleteCopy
⊢ PolishSpace ↑↑s

tactic: exact inferInstanceAs (PolishSpace s.CompleteCopy)
state_before: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology s.CompleteCopy
⊢ PolishSpace ↑↑s
state_after: no goals
Theorem: linearIndependent_iff_card_le_finrank_span
File: Mathlib/LinearAlgebra/Dimension/DivisionRing.lean

tactic: rw [linearIndependent_iff_card_eq_finrank_span, (finrank_range_le_card _).le_iff_eq]
state_before: K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_2
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b ↔ Fintype.card ι ≤ Set.finrank K (range b)
state_after: no goals
Theorem: Real.hasStrictDerivAt_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: exact mod_cast h
state_before: x : ℝ
h : cos x ≠ 0
⊢ Complex.cos ↑x ≠ 0
state_after: no goals
Theorem: CategoryTheory.Limits.IsTerminal.hasTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
h : IsTerminal X
F : Discrete PEmpty.{1} ⥤ C
⊢ (X_1 : Discrete PEmpty.{1}) → ((Functor.const (Discrete PEmpty.{1})).obj X).obj X_1 ⟶ F.obj X_1
state_after: no goals

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
h : IsTerminal X
F : Discrete PEmpty.{1} ⥤ C
⊢ ∀ ⦃X_1 Y : Discrete PEmpty.{1}⦄ (f : X_1 ⟶ Y),
    ((Functor.const (Discrete PEmpty.{1})).obj X).map f ≫ id (Discrete.casesOn Y fun as => ⋯.elim) =
      id (Discrete.casesOn X_1 fun as => ⋯.elim) ≫ F.map f
state_after: no goals
Theorem: StrictConcaveOn.strictAntiOn_deriv
File: Mathlib/Analysis/Convex/Deriv.lean

tactic: simpa only [Pi.neg_def, deriv.neg, neg_neg] using
  (hfc.neg.strictMonoOn_deriv (fun x hx ↦ (hfd x hx).neg)).neg
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConcaveOn ℝ S f
hfd : ∀ x ∈ S, DifferentiableAt ℝ f x
⊢ StrictAntiOn (deriv f) S
state_after: no goals
Theorem: MeasureTheory.AECover.integrable_of_lintegral_nnnorm_bounded
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: refine ⟨hfm, (le_of_tendsto ?_ hbounded).trans_lt ENNReal.ofReal_lt_top⟩
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : NormedAddCommGroup E
inst✝¹ : l.NeBot
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
I : ℝ
hfm : AEStronglyMeasurable f μ
hbounded : ∀ᶠ (i : ι) in l, ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ ≤ ENNReal.ofReal I
⊢ Integrable f μ
state_after: α : Type u_1
ι : Type u_2
E : Type u_3
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : NormedAddCommGroup E
inst✝¹ : l.NeBot
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
I : ℝ
hfm : AEStronglyMeasurable f μ
hbounded : ∀ᶠ (i : ι) in l, ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ ≤ ENNReal.ofReal I
⊢ Tendsto (fun c => ∫⁻ (x : α) in φ c, ↑‖f x‖₊ ∂μ) l (𝓝 (∫⁻ (a : α), ↑‖f a‖₊ ∂μ))

tactic: exact hφ.lintegral_tendsto_of_countably_generated hfm.ennnorm
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : NormedAddCommGroup E
inst✝¹ : l.NeBot
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
I : ℝ
hfm : AEStronglyMeasurable f μ
hbounded : ∀ᶠ (i : ι) in l, ∫⁻ (x : α) in φ i, ↑‖f x‖₊ ∂μ ≤ ENNReal.ofReal I
⊢ Tendsto (fun c => ∫⁻ (x : α) in φ c, ↑‖f x‖₊ ∂μ) l (𝓝 (∫⁻ (a : α), ↑‖f a‖₊ ∂μ))
state_after: no goals
Theorem: ENNReal.le_tsum_schlomilch
File: Mathlib/Analysis/PSeries.lean

tactic: rw [ENNReal.tsum_eq_iSup_nat' hu.tendsto_atTop]
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
⊢ ∑' (k : ℕ), f k ≤ ∑ k ∈ range (u 0), f k + ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)
state_after: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
⊢ ⨆ i, ∑ a ∈ range (u i), f a ≤ ∑ k ∈ range (u 0), f k + ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)

tactic: refine iSup_le fun n =>
  (Finset.le_sum_schlomilch hf h_pos hu.monotone n).trans (add_le_add_left ?_ _)
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
⊢ ⨆ i, ∑ a ∈ range (u i), f a ≤ ∑ k ∈ range (u 0), f k + ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)
state_after: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
⊢ ∑ k ∈ range n, (u (k + 1) - u k) • f (u k) ≤ ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)

tactic: have (k : ℕ) : (u (k + 1) - u k : ℝ≥0∞) = (u (k + 1) - (u k : ℕ) : ℕ) := by
  simp [NNReal.coe_sub (Nat.cast_le (α := ℝ≥0).mpr <| (hu k.lt_succ_self).le)]
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
⊢ ∑ k ∈ range n, (u (k + 1) - u k) • f (u k) ≤ ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)
state_after: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
this : ∀ (k : ℕ), ↑(u (k + 1)) - ↑(u k) = ↑(u (k + 1) - u k)
⊢ ∑ k ∈ range n, (u (k + 1) - u k) • f (u k) ≤ ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)

tactic: simp only [nsmul_eq_mul, this]
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
this : ∀ (k : ℕ), ↑(u (k + 1)) - ↑(u k) = ↑(u (k + 1) - u k)
⊢ ∑ k ∈ range n, (u (k + 1) - u k) • f (u k) ≤ ∑' (k : ℕ), (↑(u (k + 1)) - ↑(u k)) * f (u k)
state_after: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
this : ∀ (k : ℕ), ↑(u (k + 1)) - ↑(u k) = ↑(u (k + 1) - u k)
⊢ ∑ x ∈ range n, ↑(u (x + 1) - u x) * f (u x) ≤ ∑' (k : ℕ), ↑(u (k + 1) - u k) * f (u k)

tactic: apply ENNReal.sum_le_tsum
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n : ℕ
this : ∀ (k : ℕ), ↑(u (k + 1)) - ↑(u k) = ↑(u (k + 1) - u k)
⊢ ∑ x ∈ range n, ↑(u (x + 1) - u x) * f (u x) ≤ ∑' (k : ℕ), ↑(u (k + 1) - u k) * f (u k)
state_after: no goals

tactic: simp [NNReal.coe_sub (Nat.cast_le (α := ℝ≥0).mpr <| (hu k.lt_succ_self).le)]
state_before: u : ℕ → ℕ
f : ℕ → ℝ≥0∞
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu : StrictMono u
n k : ℕ
⊢ ↑(u (k + 1)) - ↑(u k) = ↑(u (k + 1) - u k)
state_after: no goals
Theorem: List.map_tail
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
l : List α
⊢ map f l.tail = (map f l).tail
state_after: no goals
Theorem: EMetric.infEdist_pos_iff_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [mem_closure_iff_infEdist_zero, pos_iff_ne_zero]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
⊢ 0 < infEdist x E ↔ x ∉ closure E
state_after: no goals
Theorem: CategoryTheory.braiding_rightUnitor_aux₁
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (α_ X (𝟙_ C) (𝟙_ C)).inv ≫ (β_ (𝟙_ C) X).inv ▷ 𝟙_ C ≫ (α_ (𝟙_ C) X (𝟙_ C)).hom ≫ 𝟙_ C ◁ (ρ_ X).hom =
    X ◁ (ρ_ (𝟙_ C)).hom ≫ (β_ (𝟙_ C) X).inv
state_after: no goals
Theorem: SupPrime.ne_bot
File: Mathlib/Order/Irreducible.lean

tactic: rintro rfl
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≠ ⊥
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime ⊥
⊢ False

tactic: exact not_supPrime_bot ha
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime ⊥
⊢ False
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.of_lintegral_ne_top
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: refine finMeasSupp_iff.2 fun b hb => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
h : f.lintegral μ ≠ ⊤
⊢ f.FinMeasSupp μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
h : f.lintegral μ ≠ ⊤
b : ℝ≥0∞
hb : b ≠ 0
⊢ μ (↑f ⁻¹' {b}) < ⊤

tactic: rw [f.lintegral_eq_of_subset' (Finset.subset_insert b _)] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
h : f.lintegral μ ≠ ⊤
b : ℝ≥0∞
hb : b ≠ 0
⊢ μ (↑f ⁻¹' {b}) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
b : ℝ≥0∞
h : ∑ x ∈ insert b (f.range \ {0}), x * μ (↑f ⁻¹' {x}) ≠ ⊤
hb : b ≠ 0
⊢ μ (↑f ⁻¹' {b}) < ⊤

tactic: refine ENNReal.lt_top_of_mul_ne_top_right ?_ hb
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
b : ℝ≥0∞
h : ∑ x ∈ insert b (f.range \ {0}), x * μ (↑f ⁻¹' {x}) ≠ ⊤
hb : b ≠ 0
⊢ μ (↑f ⁻¹' {b}) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
b : ℝ≥0∞
h : ∑ x ∈ insert b (f.range \ {0}), x * μ (↑f ⁻¹' {x}) ≠ ⊤
hb : b ≠ 0
⊢ b * μ (↑f ⁻¹' {b}) ≠ ⊤

tactic: exact (lt_top_of_sum_ne_top h (Finset.mem_insert_self _ _)).ne
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
b : ℝ≥0∞
h : ∑ x ∈ insert b (f.range \ {0}), x * μ (↑f ⁻¹' {x}) ≠ ⊤
hb : b ≠ 0
⊢ b * μ (↑f ⁻¹' {b}) ≠ ⊤
state_after: no goals
Theorem: MeasureTheory.Submartingale.smul_nonpos
File: Mathlib/Probability/Martingale/Basic.lean

tactic: rw [← neg_neg c, (by ext (i x); simp : - -c • f = -(-c • f))]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
⊢ Supermartingale (c • f) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
⊢ Supermartingale (-(-c • f)) ℱ μ

tactic: exact (hf.smul_nonneg <| neg_nonneg.2 hc).neg
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
⊢ Supermartingale (-(-c • f)) ℱ μ
state_after: no goals

tactic: ext (i x)
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
⊢ - -c • f = -(-c • f)
state_after: case h.h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
i : ι
x : Ω
⊢ (- -c • f) i x = (-(-c • f)) i x

tactic: simp
state_before: case h.h
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁷ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
F : Type u_4
inst✝³ : NormedLatticeAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
inst✝ : OrderedSMul ℝ F
f : ι → Ω → F
c : ℝ
hc : c ≤ 0
hf : Submartingale f ℱ μ
i : ι
x : Ω
⊢ (- -c • f) i x = (-(-c • f)) i x
state_after: no goals
Theorem: Finset.inf_sdiff_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction hs using Finset.Nonempty.cons_induction with
| singleton => rw [inf_singleton, inf_singleton]
| cons _ _ _ _ ih => rw [inf_cons, inf_cons, ih, inf_sdiff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
hs : s.Nonempty
f : ι → α
a : α
⊢ (s.inf fun b => f b \ a) = s.inf f \ a
state_after: no goals

tactic: rw [inf_singleton, inf_singleton]
state_before: case singleton
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
f : ι → α
a : α
a✝ : ι
⊢ ({a✝}.inf fun b => f b \ a) = {a✝}.inf f \ a
state_after: no goals

tactic: rw [inf_cons, inf_cons, ih, inf_sdiff]
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
f : ι → α
a : α
a✝ : ι
s✝ : Finset ι
h✝ : a✝ ∉ s✝
hs✝ : s✝.Nonempty
ih : (s✝.inf fun b => f b \ a) = s✝.inf f \ a
⊢ ((cons a✝ s✝ h✝).inf fun b => f b \ a) = (cons a✝ s✝ h✝).inf f \ a
state_after: no goals
Theorem: monovary_inv_right₀
File: Mathlib/Algebra/Order/Monovary.lean

tactic: erw [inv_lt_inv (hg _) (hg _)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : LinearOrderedSemifield β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
hg : StrongLT 0 g
i j : ι
⊢ g⁻¹ j < g⁻¹ i → f j ≤ f i ↔ g i < g j → f j ≤ f i
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.leftUnshift_smul
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

tactic: change (leftShiftLinearEquiv  R K L n a n' hn).symm (x • γ) = _
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
x : R
⊢ (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
x : R
⊢ (leftShiftLinearEquiv R K L n a n' hn).symm (x • γ) = x • γ.leftUnshift n hn

tactic: apply map_smul
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
x : R
⊢ (leftShiftLinearEquiv R K L n a n' hn).symm (x • γ) = x • γ.leftUnshift n hn
state_after: no goals
Theorem: Subgroup.leftTransversals.smul_diff_smul
File: Mathlib/GroupTheory/Transfer.lean

tactic: simp only [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul, mul_inv_rev, mul_assoc,
  inv_mul_cancel_left, toPerm_symm_apply]
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type u_2
inst✝¹ : CommGroup A
ϕ : ↥H →* A
R S T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
g : G
x✝¹ : Fintype (G ⧸ H) := H.fintypeQuotientOfFiniteIndex
x✝ : G ⧸ H
⊢ ϕ ⟨(↑((MemLeftTransversals.toEquiv ⋯) x✝))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) x✝), ⋯⟩ =
    ϕ
      ⟨(↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)))⁻¹ *
          ↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)),
        ⋯⟩
state_after: no goals
Theorem: Set.sUnion_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [sUnion_eq_biUnion, biUnion_iUnion]
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 (Set α)
⊢ ⋃₀ ⋃ i, s i = ⋃ i, ⋃₀ s i
state_after: no goals
Theorem: Real.tan_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tan, neg_div]
state_before: x y : ℝ
⊢ tan (-x) = -tan x
state_after: no goals