1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.mem_takeWhile_imp
File: Mathlib/Data/List/Basic.lean

tactic: cases hp : p hd
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx :
  x ∈
    match p hd with
    | true => hd :: takeWhile p tl
    | false => []
⊢ p x = true
state_after: case cons.false
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx :
  x ∈
    match p hd with
    | true => hd :: takeWhile p tl
    | false => []
hp : p hd = false
⊢ p x = true

case cons.true
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx :
  x ∈
    match p hd with
    | true => hd :: takeWhile p tl
    | false => []
hp : p hd = true
⊢ p x = true

tactic: simp [hp] at hx
state_before: case cons.false
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx :
  x ∈
    match p hd with
    | true => hd :: takeWhile p tl
    | false => []
hp : p hd = false
⊢ p x = true
state_after: no goals

tactic: rw [hp, mem_cons] at hx
state_before: case cons.true
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx :
  x ∈
    match p hd with
    | true => hd :: takeWhile p tl
    | false => []
hp : p hd = true
⊢ p x = true
state_after: case cons.true
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx : x = hd ∨ x ∈ takeWhile p tl
hp : p hd = true
⊢ p x = true

tactic: rcases hx with (rfl | hx)
state_before: case cons.true
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hx : x = hd ∨ x ∈ takeWhile p tl
hp : p hd = true
⊢ p x = true
state_after: case cons.true.inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hp : p x = true
⊢ p x = true

case cons.true.inr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hp : p hd = true
hx : x ∈ takeWhile p tl
⊢ p x = true

tactic: exact hp
state_before: case cons.true.inl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hp : p x = true
⊢ p x = true
state_after: no goals

tactic: exact IH hx
state_before: case cons.true.inr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
x hd : α
tl : List α
IH : x ∈ takeWhile p tl → p x = true
hp : p hd = true
hx : x ∈ takeWhile p tl
⊢ p x = true
state_after: no goals
Theorem: ContDiffBump.normed_convolution_eq_right
File: Mathlib/Analysis/Calculus/BumpFunction/Convolution.lean

tactic: rw [convolution_eq_right' _ φ.support_normed_eq.subset hg]
state_before: G : Type uG
E' : Type uE'
inst✝¹⁰ : NormedAddCommGroup E'
g : G → E'
inst✝⁹ : MeasurableSpace G
μ : Measure G
inst✝⁸ : NormedSpace ℝ E'
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace ℝ G
inst✝⁵ : HasContDiffBump G
inst✝⁴ : CompleteSpace E'
φ : ContDiffBump 0
x₀✝ : G
inst✝³ : BorelSpace G
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : μ.IsOpenPosMeasure
inst✝ : FiniteDimensional ℝ G
x₀ : G
hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀
⊢ (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀ = g x₀
state_after: G : Type uG
E' : Type uE'
inst✝¹⁰ : NormedAddCommGroup E'
g : G → E'
inst✝⁹ : MeasurableSpace G
μ : Measure G
inst✝⁸ : NormedSpace ℝ E'
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace ℝ G
inst✝⁵ : HasContDiffBump G
inst✝⁴ : CompleteSpace E'
φ : ContDiffBump 0
x₀✝ : G
inst✝³ : BorelSpace G
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : μ.IsOpenPosMeasure
inst✝ : FiniteDimensional ℝ G
x₀ : G
hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀
⊢ ∫ (t : G), ((lsmul ℝ ℝ) (φ.normed μ t)) (g x₀) ∂μ = g x₀

tactic: exact integral_normed_smul φ μ (g x₀)
state_before: G : Type uG
E' : Type uE'
inst✝¹⁰ : NormedAddCommGroup E'
g : G → E'
inst✝⁹ : MeasurableSpace G
μ : Measure G
inst✝⁸ : NormedSpace ℝ E'
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace ℝ G
inst✝⁵ : HasContDiffBump G
inst✝⁴ : CompleteSpace E'
φ : ContDiffBump 0
x₀✝ : G
inst✝³ : BorelSpace G
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : μ.IsOpenPosMeasure
inst✝ : FiniteDimensional ℝ G
x₀ : G
hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀
⊢ ∫ (t : G), ((lsmul ℝ ℝ) (φ.normed μ t)) (g x₀) ∂μ = g x₀
state_after: no goals
Theorem: Con.sSup_eq_conGen
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: rw [conGen_eq]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = conGen fun x y => ∃ c ∈ S, c x y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = sInf {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}

tactic: apply congr_arg sInf
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = sInf {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ upperBounds S = {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}

tactic: ext
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ upperBounds S = {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝ : Con M
⊢ x✝ ∈ upperBounds S ↔ x✝ ∈ {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}

tactic: exact ⟨fun h _ _ ⟨r, hr⟩ => h hr.1 hr.2, fun h r hS _ _ hr => h _ _ ⟨r, hS, hr⟩⟩
state_before: case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝ : Con M
⊢ x✝ ∈ upperBounds S ↔ x✝ ∈ {s | ∀ (x y : M), (∃ c ∈ S, c x y) → s x y}
state_after: no goals
Theorem: Finset.exists_lt_of_prod_lt'
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: contrapose! Hlt with Hle
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hlt : ∏ i ∈ s, f i < ∏ i ∈ s, g i
⊢ ∃ i ∈ s, f i < g i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ i ∈ s, g i ≤ f i
⊢ ∏ i ∈ s, g i ≤ ∏ i ∈ s, f i

tactic: exact prod_le_prod' Hle
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ i ∈ s, g i ≤ f i
⊢ ∏ i ∈ s, g i ≤ ∏ i ∈ s, f i
state_after: no goals
Theorem: Nat.Prime.eq_one_or_self_of_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: obtain ⟨n, hn⟩ := hm
state_before: n p : ℕ
pp : Prime p
m : ℕ
hm : m ∣ p
⊢ m = 1 ∨ m = p
state_after: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
⊢ m = 1 ∨ m = p

tactic: have := pp.isUnit_or_isUnit hn
state_before: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
⊢ m = 1 ∨ m = p
state_after: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : IsUnit m ∨ IsUnit n
⊢ m = 1 ∨ m = p

tactic: rw [Nat.isUnit_iff, Nat.isUnit_iff] at this
state_before: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : IsUnit m ∨ IsUnit n
⊢ m = 1 ∨ m = p
state_after: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : m = 1 ∨ n = 1
⊢ m = 1 ∨ m = p

tactic: apply Or.imp_right _ this
state_before: case intro
n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : m = 1 ∨ n = 1
⊢ m = 1 ∨ m = p
state_after: n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : m = 1 ∨ n = 1
⊢ n = 1 → m = p

tactic: rintro rfl
state_before: n✝ p : ℕ
pp : Prime p
m n : ℕ
hn : p = m * n
this : m = 1 ∨ n = 1
⊢ n = 1 → m = p
state_after: n p : ℕ
pp : Prime p
m : ℕ
hn : p = m * 1
this : m = 1 ∨ 1 = 1
⊢ m = p

tactic: rw [hn, mul_one]
state_before: n p : ℕ
pp : Prime p
m : ℕ
hn : p = m * 1
this : m = 1 ∨ 1 = 1
⊢ m = p
state_after: no goals
Theorem: Fin.cycleRange_apply
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: split_ifs with h₁ h₂
state_before: n : ℕ
i j : Fin n.succ
⊢ i.cycleRange j = if j < i then j + 1 else if j = i then 0 else j
state_after: case pos
n : ℕ
i j : Fin n.succ
h₁ : j < i
⊢ i.cycleRange j = j + 1

case pos
n : ℕ
i j : Fin n.succ
h₁ : ¬j < i
h₂ : j = i
⊢ i.cycleRange j = 0

case neg
n : ℕ
i j : Fin n.succ
h₁ : ¬j < i
h₂ : ¬j = i
⊢ i.cycleRange j = j

tactic: exact cycleRange_of_lt h₁
state_before: case pos
n : ℕ
i j : Fin n.succ
h₁ : j < i
⊢ i.cycleRange j = j + 1
state_after: no goals

tactic: exact cycleRange_of_eq h₂
state_before: case pos
n : ℕ
i j : Fin n.succ
h₁ : ¬j < i
h₂ : j = i
⊢ i.cycleRange j = 0
state_after: no goals

tactic: exact cycleRange_of_gt (lt_of_le_of_ne (le_of_not_gt h₁) (Ne.symm h₂))
state_before: case neg
n : ℕ
i j : Fin n.succ
h₁ : ¬j < i
h₂ : ¬j = i
⊢ i.cycleRange j = j
state_after: no goals
Theorem: Equiv.Perm.two_dvd_card_support
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [_root_.le_antisymm
    (Nat.le_of_dvd zero_lt_two <|
      (dvd_of_mem_cycleType hn).trans <| orderOf_dvd_of_pow_eq_one hσ)
    (two_le_of_mem_cycleType hn)]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
hσ : σ ^ 2 = 1
n : ℕ
hn : n ∈ σ.cycleType
⊢ 2 ∣ n
state_after: no goals
Theorem: CategoryTheory.ShortComplex.leftHomology_ext_iff
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

tactic: rw [cancel_epi]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasLeftHomology
A : C
f₁ f₂ : S.leftHomology ⟶ A
⊢ f₁ = f₂ ↔ S.leftHomologyπ ≫ f₁ = S.leftHomologyπ ≫ f₂
state_after: no goals
Theorem: Ordinal.nmul_zero
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [← Ordinal.le_zero, nmul_le_iff]
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ a ⨳ 0 = 0
state_after: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ ∀ a' < a, ∀ b' < 0, a' ⨳ 0 ♯ a ⨳ b' < 0 ♯ a' ⨳ b'

tactic: exact fun _ _ a ha => (Ordinal.not_lt_zero a ha).elim
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ ∀ a' < a, ∀ b' < 0, a' ⨳ 0 ♯ a ⨳ b' < 0 ♯ a' ⨳ b'
state_after: no goals
Theorem: Set.mulIndicator_mul
File: Mathlib/Algebra/Group/Indicator.lean

tactic: funext
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ (s.mulIndicator fun a => f a * g a) = fun a => s.mulIndicator f a * s.mulIndicator g a
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ s.mulIndicator (fun a => f a * g a) x✝ = s.mulIndicator f x✝ * s.mulIndicator g x✝

tactic: simp only [mulIndicator]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ s.mulIndicator (fun a => f a * g a) x✝ = s.mulIndicator f x✝ * s.mulIndicator g x✝
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ (if x✝ ∈ s then f x✝ * g x✝ else 1) = (if x✝ ∈ s then f x✝ else 1) * if x✝ ∈ s then g x✝ else 1

tactic: split_ifs
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ (if x✝ ∈ s then f x✝ * g x✝ else 1) = (if x✝ ∈ s then f x✝ else 1) * if x✝ ∈ s then g x✝ else 1
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∈ s
⊢ f x✝ * g x✝ = f x✝ * g x✝

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∉ s
⊢ 1 = 1 * 1

tactic: rw [mul_one]
state_before: case neg
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∉ s
⊢ 1 = 1 * 1
state_after: no goals

tactic: rfl
state_before: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∈ s
⊢ f x✝ * g x✝ = f x✝ * g x✝
state_after: no goals
Theorem: LinearMap.ker_eq_bot_iff_range_eq_top
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [range_eq_top, ker_eq_bot, injective_iff_surjective]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ ker f = ⊥ ↔ range f = ⊤
state_after: no goals
Theorem: List.take_range
File: Mathlib/Data/List/Range.lean

tactic: apply List.ext_getElem
state_before: α : Type u
m n : ℕ
⊢ take m (range n) = range (min m n)
state_after: case hl
α : Type u
m n : ℕ
⊢ (take m (range n)).length = (range (min m n)).length

case h
α : Type u
m n : ℕ
⊢ ∀ (n_1 : ℕ) (h₁ : n_1 < (take m (range n)).length) (h₂ : n_1 < (range (min m n)).length),
    (take m (range n))[n_1] = (range (min m n))[n_1]

tactic: simp
state_before: case hl
α : Type u
m n : ℕ
⊢ (take m (range n)).length = (range (min m n)).length
state_after: no goals

tactic: simp (config := { contextual := true }) [← getElem_take, Nat.lt_min]
state_before: case h
α : Type u
m n : ℕ
⊢ ∀ (n_1 : ℕ) (h₁ : n_1 < (take m (range n)).length) (h₂ : n_1 < (range (min m n)).length),
    (take m (range n))[n_1] = (range (min m n))[n_1]
state_after: no goals
Theorem: TendstoUniformlyOnFilter.tendsto_at
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: refine Uniform.tendsto_nhds_right.mpr fun u hu => mem_map.mpr ?_
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
⊢ Tendsto (fun n => F n x) p (𝓝 (f x))
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ (fun x_1 => (f x, F x_1 x)) ⁻¹' u ∈ p

tactic: filter_upwards [(h u hu).curry]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ (fun x_1 => (f x, F x_1 x)) ⁻¹' u ∈ p
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ (a : ι), (∀ᶠ (y : α) in p', (f y, F a y) ∈ u) → a ∈ (fun x_1 => (f x, F x_1 x)) ⁻¹' u

tactic: intro i h
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ (a : ι), (∀ᶠ (y : α) in p', (f y, F a y) ∈ u) → a ∈ (fun x_1 => (f x, F x_1 x)) ⁻¹' u
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h✝ : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
i : ι
h : ∀ᶠ (y : α) in p', (f y, F i y) ∈ u
⊢ i ∈ (fun x_1 => (f x, F x_1 x)) ⁻¹' u

tactic: simpa using h.filter_mono hx
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h✝ : TendstoUniformlyOnFilter F f p p'
hx : 𝓟 {x} ≤ p'
u : Set (β × β)
hu : u ∈ 𝓤 β
i : ι
h : ∀ᶠ (y : α) in p', (f y, F i y) ∈ u
⊢ i ∈ (fun x_1 => (f x, F x_1 x)) ⁻¹' u
state_after: no goals
Theorem: Quaternion.normSq_ratCast
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [← coe_ratCast, normSq_coe, coe_pow]
state_before: R : Type u_1
inst✝ : LinearOrderedField R
a b : ℍ[R]
q : ℚ
⊢ ↑(normSq ↑q) = ↑q ^ 2
state_after: no goals
Theorem: List.forall₂_nil_right_iff
File: Mathlib/Data/List/Forall2.lean

tactic: cases H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List α
H : Forall₂ R l []
⊢ l = []
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ [] = []

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ [] = []
state_after: no goals

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l : List α
⊢ l = [] → Forall₂ R l []
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ Forall₂ R [] []

tactic: exact Forall₂.nil
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
⊢ Forall₂ R [] []
state_after: no goals
Theorem: ByteArray.get_extract_aux
File: .lake/packages/batteries/Batteries/Data/ByteArray.lean

tactic: apply Nat.add_lt_of_lt_sub'
state_before: i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ start + i < a.size
state_after: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ i < a.size - start

tactic: apply Nat.lt_of_lt_of_le h
state_before: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ i < a.size - start
state_after: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ (a.extract start stop).size ≤ a.size - start

tactic: rw [size_extract, ← Nat.sub_min_sub_right]
state_before: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ (a.extract start stop).size ≤ a.size - start
state_after: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ min (stop - start) (a.size - start) ≤ a.size - start

tactic: exact Nat.min_le_right ..
state_before: case a
i : Nat
a : ByteArray
start stop : Nat
h : i < (a.extract start stop).size
⊢ min (stop - start) (a.size - start) ≤ a.size - start
state_after: no goals
Theorem: isOpen_Ioi
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: rw [← compl_Iic]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
⊢ IsOpen (Ioi a)
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
⊢ IsOpen (Iic a)ᶜ

tactic: exact isClosed_Iic.isOpen_compl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
⊢ IsOpen (Iic a)ᶜ
state_after: no goals
Theorem: Sublattice.map_top
File: Mathlib/Order/Sublattice.lean

tactic: simp [h.range_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : LatticeHom α β
h : Surjective ⇑f
⊢ ↑(map f ⊤) = ↑⊤
state_after: no goals
Theorem: Pi.segment_subset
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rintro z ⟨a, b, ha, hb, hab, hz⟩ i -
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : (i : ι) → AddCommMonoid (π i)
inst✝ : (i : ι) → Module 𝕜 (π i)
s : Set ι
x y : (i : ι) → π i
⊢ [x-[𝕜]y] ⊆ s.pi fun i => [x i-[𝕜]y i]
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : (i : ι) → AddCommMonoid (π i)
inst✝ : (i : ι) → Module 𝕜 (π i)
s : Set ι
x y z : (i : ι) → π i
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
hz : a • x + b • y = z
i : ι
⊢ z i ∈ (fun i => [x i-[𝕜]y i]) i

tactic: exact ⟨a, b, ha, hb, hab, congr_fun hz i⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : (i : ι) → AddCommMonoid (π i)
inst✝ : (i : ι) → Module 𝕜 (π i)
s : Set ι
x y z : (i : ι) → π i
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
hz : a • x + b • y = z
i : ι
⊢ z i ∈ (fun i => [x i-[𝕜]y i]) i
state_after: no goals
Theorem: DirectedOn.convex_sUnion
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [sUnion_eq_iUnion]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
c : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) c
hc : ∀ ⦃A : Set E⦄, A ∈ c → Convex 𝕜 A
⊢ Convex 𝕜 (⋃₀ c)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
c : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) c
hc : ∀ ⦃A : Set E⦄, A ∈ c → Convex 𝕜 A
⊢ Convex 𝕜 (⋃ i, ↑i)

tactic: exact (directedOn_iff_directed.1 hdir).convex_iUnion fun A => hc A.2
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
c : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) c
hc : ∀ ⦃A : Set E⦄, A ∈ c → Convex 𝕜 A
⊢ Convex 𝕜 (⋃ i, ↑i)
state_after: no goals
Theorem: Polynomial.aroots_neg
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [aroots, Polynomial.map_neg, roots_neg]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p✝ q : R[X]
inst✝³ : CommRing T
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
p : T[X]
⊢ (-p).aroots S = p.aroots S
state_after: no goals
Theorem: Fin.predAbove_last_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [predAbove_of_le_castSucc _ _ (castSucc_le_castSucc_iff.mpr (le_last _)), castPred_castSucc]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ (last n).predAbove i.castSucc = i
state_after: no goals
Theorem: Mathlib.Meta.Positivity.ite_pos
File: Mathlib/Tactic/Positivity/Basic.lean

tactic: by_cases p <;> simp [*]
state_before: α : Type u_1
inst✝² : Zero α
p : Prop
inst✝¹ : Decidable p
a b : α
inst✝ : LT α
ha : 0 < a
hb : 0 < b
⊢ 0 < if p then a else b
state_after: no goals
Theorem: Rat.neg_divInt
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: rcases Int.eq_nat_or_neg d with ⟨_, rfl | rfl⟩ <;> simp [divInt_neg', neg_mkRat]
state_before: n d : Int
⊢ -(n /. d) = -n /. d
state_after: no goals
Theorem: zpow_sub_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← zpow_add_one, Int.sub_add_cancel]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹
state_after: no goals