1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Stream'.WSeq.head_terminates_of_head_tail_terminates
File: Mathlib/Data/Seq/WSeq.lean

tactic: rcases (head_terminates_iff _).1 T with ⟨⟨a, h⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
⊢ s.destruct.Terminates
state_after: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ s.tail.destruct
⊢ s.destruct.Terminates

tactic: simp? [tail] at h says simp only [tail, destruct_flatten] at h
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ s.tail.destruct
⊢ s.destruct.Terminates
state_after: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
⊢ s.destruct.Terminates

tactic: rcases exists_of_mem_bind h with ⟨s', h1, _⟩
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
⊢ s.destruct.Terminates
state_after: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates

tactic: unfold Functor.map at h1
state_before: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
state_after: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates

tactic: exact
  let ⟨t, h3, _⟩ := Computation.exists_of_mem_map h1
  Computation.terminates_of_mem h3
state_before: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
state_after: no goals

tactic: simp only [tail, destruct_flatten] at h
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ s.tail.destruct
⊢ s.destruct.Terminates
state_after: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
⊢ s.destruct.Terminates
Theorem: IsPurelyInseparable.insepDegree_eq
File: Mathlib/FieldTheory/PurelyInseparable.lean

tactic: rw [insepDegree, separableClosure.eq_bot_of_isPurelyInseparable, rank_bot']
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsPurelyInseparable F E
⊢ insepDegree F E = Module.rank F E
state_after: no goals
Theorem: Int.card_Ioo_of_lt
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_Ioo, sub_sub, toNat_sub_of_le h]
state_before: a b : ℤ
h : a < b
⊢ ↑(Ioo a b).card = b - a - 1
state_after: no goals
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_opposite
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete Cᵒᵖ ↔ IsIdempotentComplete C
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete Cᵒᵖ → IsIdempotentComplete C

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete C → IsIdempotentComplete Cᵒᵖ

tactic: exact isIdempotentComplete_of_isIdempotentComplete_opposite
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete Cᵒᵖ → IsIdempotentComplete C
state_after: no goals

tactic: intro h
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete C → IsIdempotentComplete Cᵒᵖ
state_after: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖ

tactic: apply isIdempotentComplete_of_isIdempotentComplete_opposite
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖ
state_after: case mpr.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖᵒᵖ

tactic: rw [isIdempotentComplete_iff_of_equivalence (opOpEquivalence C)]
state_before: case mpr.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖᵒᵖ
state_after: case mpr.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete C

tactic: exact h
state_before: case mpr.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete C
state_after: no goals
Theorem: Set.Intersecting.disjoint_map_compl
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: rw [Finset.disjoint_left]
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ Disjoint s (map { toFun := compl, inj' := ⋯ } s)
state_after: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ ∀ ⦃a : α⦄, a ∈ s → a ∉ map { toFun := compl, inj' := ⋯ } s

tactic: rintro x hx hxc
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
⊢ ∀ ⦃a : α⦄, a ∈ s → a ∉ map { toFun := compl, inj' := ⋯ } s
state_after: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx : x ∈ s
hxc : x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False

tactic: obtain ⟨x, hx', rfl⟩ := mem_map.mp hxc
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx : x ∈ s
hxc : x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
state_after: case intro.intro
α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx' : x ∈ s
hx : { toFun := compl, inj' := ⋯ } x ∈ s
hxc : { toFun := compl, inj' := ⋯ } x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False

tactic: exact hs.not_compl_mem hx' hx
state_before: case intro.intro
α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : (↑s).Intersecting
x : α
hx' : x ∈ s
hx : { toFun := compl, inj' := ⋯ } x ∈ s
hxc : { toFun := compl, inj' := ⋯ } x ∈ map { toFun := compl, inj' := ⋯ } s
⊢ False
state_after: no goals
Theorem: Left.one_le_pow_of_le
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

tactic: rw [pow_succ]
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : 1 ≤ x
n : ℕ
⊢ 1 ≤ x ^ (n + 1)
state_after: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : 1 ≤ x
n : ℕ
⊢ 1 ≤ x ^ n * x

tactic: exact Left.one_le_mul (Left.one_le_pow_of_le hx) hx
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : 1 ≤ x
n : ℕ
⊢ 1 ≤ x ^ n * x
state_after: no goals
Theorem: wbtw_pointReflection
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine ⟨2⁻¹, ⟨by norm_num, by norm_num⟩, ?_⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ Wbtw R y x ((pointReflection R x) y)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ (lineMap y ((pointReflection R x) y)) 2⁻¹ = x

tactic: rw [lineMap_apply, pointReflection_apply, vadd_vsub_assoc, ← two_smul R (x -ᵥ y)]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ (lineMap y ((pointReflection R x) y)) 2⁻¹ = x
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 2⁻¹ • 2 • (x -ᵥ y) +ᵥ y = x

tactic: simp
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 2⁻¹ • 2 • (x -ᵥ y) +ᵥ y = x
state_after: no goals

tactic: norm_num
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 0 ≤ 2⁻¹
state_after: no goals

tactic: norm_num
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
⊢ 2⁻¹ ≤ 1
state_after: no goals
Theorem: Fin.prod_univ_get'
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [Finset.prod_eq_multiset_prod]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
l : List α
f : α → β
⊢ ∏ i : Fin l.length, f l[↑i] = (List.map f l).prod
state_after: no goals
Theorem: MeasureTheory.tendsto_measure_of_tendsto_indicator
File: Mathlib/MeasureTheory/Integral/Indicator.lean

tactic: apply tendsto_measure_of_ae_tendsto_indicator L ?_ As_mble B_mble B_finmeas As_le_B
      (ae_of_all μ h_lim)
state_before: α : Type u_1
inst✝² : MeasurableSpace α
A : Set α
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
As : ι → Set α
inst✝ : L.NeBot
μ : Measure α
As_mble : ∀ (i : ι), MeasurableSet (As i)
B : Set α
B_mble : MeasurableSet B
B_finmeas : μ B ≠ ⊤
As_le_B : ∀ᶠ (i : ι) in L, As i ⊆ B
h_lim : ∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A
⊢ Tendsto (fun i => μ (As i)) L (𝓝 (μ A))
state_after: α : Type u_1
inst✝² : MeasurableSpace α
A : Set α
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
As : ι → Set α
inst✝ : L.NeBot
μ : Measure α
As_mble : ∀ (i : ι), MeasurableSet (As i)
B : Set α
B_mble : MeasurableSet B
B_finmeas : μ B ≠ ⊤
As_le_B : ∀ᶠ (i : ι) in L, As i ⊆ B
h_lim : ∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A
⊢ MeasurableSet A

tactic: exact measurableSet_of_tendsto_indicator L As_mble h_lim
state_before: α : Type u_1
inst✝² : MeasurableSpace α
A : Set α
ι : Type u_2
L : Filter ι
inst✝¹ : L.IsCountablyGenerated
As : ι → Set α
inst✝ : L.NeBot
μ : Measure α
As_mble : ∀ (i : ι), MeasurableSet (As i)
B : Set α
B_mble : MeasurableSet B
B_finmeas : μ B ≠ ⊤
As_le_B : ∀ᶠ (i : ι) in L, As i ⊆ B
h_lim : ∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A
⊢ MeasurableSet A
state_after: no goals
Theorem: CoxeterSystem.length_mul_le
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: rcases cs.exists_reduced_word w₁ with ⟨ω₁, hω₁, rfl⟩
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₁ w₂ : W
⊢ cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂
state_after: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₂ : W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
⊢ cs.length (cs.wordProd ω₁ * w₂) ≤ cs.length (cs.wordProd ω₁) + cs.length w₂

tactic: rcases cs.exists_reduced_word w₂ with ⟨ω₂, hω₂, rfl⟩
state_before: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₂ : W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
⊢ cs.length (cs.wordProd ω₁ * w₂) ≤ cs.length (cs.wordProd ω₁) + cs.length w₂
state_after: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)

tactic: have := cs.length_wordProd_le (ω₁ ++ ω₂)
state_before: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
state_after: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
this : cs.length (cs.wordProd (ω₁ ++ ω₂)) ≤ (ω₁ ++ ω₂).length
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)

tactic: simpa [hω₁, hω₂, wordProd_append] using this
state_before: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
this : cs.length (cs.wordProd (ω₁ ++ ω₂)) ≤ (ω₁ ++ ω₂).length
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
state_after: no goals
Theorem: Stream'.tail_iterate
File: Mathlib/Data/Stream/Init.lean

tactic: ext n
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).tail = iterate f (f a)
state_after: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ (iterate f a).tail.get n = (iterate f (f a)).get n

tactic: rw [get_tail]
state_before: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ (iterate f a).tail.get n = (iterate f (f a)).get n
state_after: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ (iterate f a).get (n + 1) = (iterate f (f a)).get n

tactic: induction' n with n' ih
state_before: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ (iterate f a).get (n + 1) = (iterate f (f a)).get n
state_after: case a.zero
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).get (0 + 1) = (iterate f (f a)).get 0

case a.succ
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n' : ℕ
ih : (iterate f a).get (n' + 1) = (iterate f (f a)).get n'
⊢ (iterate f a).get (n' + 1 + 1) = (iterate f (f a)).get (n' + 1)

tactic: rfl
state_before: case a.zero
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).get (0 + 1) = (iterate f (f a)).get 0
state_after: no goals

tactic: rw [get_succ_iterate', ih, get_succ_iterate']
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n' : ℕ
ih : (iterate f a).get (n' + 1) = (iterate f (f a)).get n'
⊢ (iterate f a).get (n' + 1 + 1) = (iterate f (f a)).get (n' + 1)
state_after: no goals
Theorem: AddMonoidAlgebra.opRingEquiv_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCommMonoid G
r : k
x : G
⊢ AddMonoidAlgebra.opRingEquiv (op (single x r)) = single x (op r)
state_after: no goals
Theorem: Subsemiring.top_prod
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_snd]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Subsemiring S
x : R × S
⊢ x ∈ ⊤.prod s ↔ x ∈ comap (RingHom.snd R S) s
state_after: no goals
Theorem: Function.Periodic.const_inv_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [inv_inv] using h.const_smul₀ a⁻¹
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : AddCommMonoid α
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Periodic f c
a : γ
⊢ Periodic (fun x => f (a⁻¹ • x)) (a • c)
state_after: no goals
Theorem: Profinite.NobelingProof.GoodProducts.smaller_factorization
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: rfl
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
⊢ (fun p => ↑p) ∘ (range_equiv_smaller C o).toFun = ⇑(πs C o) ∘ fun p => ↑p
state_after: no goals
Theorem: closedBall_add_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [(isCompact_closedBall _ _).add_closedBall hδ b, cthickening_closedBall hδ hε a,
  Metric.vadd_closedBall, vadd_eq_add, add_comm, add_comm δ]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
inst✝ : ProperSpace E
hε : 0 ≤ ε
hδ : 0 ≤ δ
a b : E
⊢ Metric.closedBall a ε + Metric.closedBall b δ = Metric.closedBall (a + b) (ε + δ)
state_after: no goals
Theorem: Option.pmap_eq_map
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [map_none', map_some', pmap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p✝ : α → Prop
f✝ : (a : α) → p✝ a → β
x✝ : Option α
p : α → Prop
f : α → β
x : Option α
H : ∀ (a : α), a ∈ x → p a
⊢ pmap (fun a x => f a) x H = Option.map f x
state_after: no goals
Theorem: Finset.prod_range_succ
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp only [mul_comm, prod_range_succ_comm]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x ∈ range (n + 1), f x = (∏ x ∈ range n, f x) * f n
state_after: no goals
Theorem: ENorm.map_neg
File: Mathlib/Analysis/NormedSpace/ENorm.lean

tactic: rw [← map_smul, neg_one_smul]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑e (-x) = ↑‖-1‖₊ * ↑e x
state_after: no goals

tactic: simp
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑‖-1‖₊ * ↑e x = ↑e x
state_after: no goals
Theorem: Module.End.IsSemisimple.maxGenEigenspace_eq_eigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean

tactic: simp_rw [maxGenEigenspace, ← (f.genEigenspace μ).monotone.iSup_nat_add 1,
  hf.genEigenspace_eq_eigenspace μ (Nat.zero_lt_succ _), ciSup_const]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
⊢ f.maxGenEigenspace μ = f.eigenspace μ
state_after: no goals
Theorem: mul_bounded_of_bounded_of_bounded
File: Mathlib/Topology/Bornology/BoundedOperation.lean

tactic: obtain ⟨C, hC⟩ := Metric.isBounded_iff.mp <|
  isBounded_mul (Metric.isBounded_range_iff.mpr f_bdd) (Metric.isBounded_range_iff.mpr g_bdd)
state_before: R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case intro
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C

tactic: use C
state_before: case intro
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C

tactic: intro x y
state_before: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
x y : X
⊢ dist ((f * g) x) ((f * g) y) ≤ C

tactic: exact hC (Set.mul_mem_mul (Set.mem_range_self (f := f) x) (Set.mem_range_self (f := g) x))
         (Set.mul_mem_mul (Set.mem_range_self (f := f) y) (Set.mem_range_self (f := g) y))
state_before: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
x y : X
⊢ dist ((f * g) x) ((f * g) y) ≤ C
state_after: no goals
Theorem: CategoryTheory.Limits.WidePullback.hom_eq_lift
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: aesop_cat
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ ∀ (j : J), (fun j => g ≫ π arrows j) j ≫ arrows j = g ≫ base arrows
state_after: no goals

tactic: apply eq_lift_of_comp_eq
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) ⋯
state_after: case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ ∀ (j : J), g ≫ π arrows j = g ≫ π arrows j

case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ g ≫ base arrows = g ≫ base arrows

tactic: aesop_cat
state_before: case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ ∀ (j : J), g ≫ π arrows j = g ≫ π arrows j
state_after: no goals

tactic: rfl
state_before: case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B objs arrows
⊢ g ≫ base arrows = g ≫ base arrows
state_after: no goals