tasksource/leandojo huggingface dataset:
Theorem: norm_expSeries_div_summable_of_mem_ball
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: change Summable (norm ∘ _)
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝² : NontriviallyNormedField 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable fun n => ‖x ^ n / ↑n !‖

tactic: rw [← expSeries_apply_eq_div' (𝕂 := 𝕂) x]
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝² : NontriviallyNormedField 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable (norm ∘ fun n => x ^ n / ↑n !)

tactic: exact norm_expSeries_summable_of_mem_ball x hx
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
inst✝² : NontriviallyNormedField 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable (norm ∘ fun n => ↑(expSeries 𝕂 𝔸 n) fun x_1 => x)
Theorem: Submodule.fst_map_fst
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_top_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.339262
M₆ : Type ?u.339265
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (LinearMap.fst R M M₂) (fst R M M₂) = ⊤

tactic: rintro x -
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.339262
M₆ : Type ?u.339265
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.fst R M M₂) (fst R M M₂)

tactic: simp only [fst, comap_bot, mem_map, mem_ker, snd_apply, fst_apply,
  Prod.exists, exists_eq_left, exists_eq]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.339262
M₆ : Type ?u.339265
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
⊢ x ∈ map (LinearMap.fst R M M₂) (fst R M M₂)
Theorem: Matrix.vecHead_vecAlt1
File: Mathlib/Data/Fin/VecNotation.lean

tactic: simp [vecHead, vecAlt1]
state_before: α : Type u
m n o : ℕ
m' : Type ?u.49095
n' : Type ?u.49098
o' : Type ?u.49101
hm : m + 2 = n + 1 + (n + 1)
v : Fin (m + 2) → α
⊢ vecHead (vecAlt1 hm v) = v 1
Theorem: IsCoprime.of_mul_add_right_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm] at h
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime (z * y + x) y
⊢ IsCoprime x y

tactic: exact h.of_add_mul_right_left
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime (x + z * y) y
⊢ IsCoprime x y
Theorem: Con.comap_eq
File: Mathlib/GroupTheory/Congruence.lean

tactic: rw [← c.eq]
state_before: M : Type u_2
N : Type u_1
P : Type ?u.53840
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y✝ : M
f : N →* M
x y : N
⊢ ↑c (↑f x) (↑f y) ↔ ↑(mk' c) (↑f x) = ↑(mk' c) (↑f y)

tactic: rfl
state_before: M : Type u_2
N : Type u_1
P : Type ?u.53840
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y✝ : M
f : N →* M
x y : N
⊢ ↑(↑f x) = ↑(↑f y) ↔ ↑(mk' c) (↑f x) = ↑(mk' c) (↑f y)
Theorem: Cycle.length_nontrivial
File: Mathlib/Data/List/Cycle.lean

tactic: obtain ⟨x, y, hxy, hx, hy⟩ := h
state_before: α : Type u_1
s : Cycle α
h : Nontrivial s
⊢ 2 ≤ length s

tactic: induction' s using Quot.inductionOn with l
state_before: case intro.intro.intro.intro
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx : x ∈ s
hy : y ∈ s
⊢ 2 ≤ length s

tactic: rcases l with (_ | ⟨hd, _ | ⟨hd', tl⟩⟩)
state_before: case intro.intro.intro.intro.h
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx✝ : x ∈ s
hy✝ : y ∈ s
l : List α
hx : x ∈ Quot.mk Setoid.r l
hy : y ∈ Quot.mk Setoid.r l
⊢ 2 ≤ length (Quot.mk Setoid.r l)

tactic: simp at hx
state_before: case intro.intro.intro.intro.h.nil
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx✝ : x ∈ s
hy✝ : y ∈ s
hx : x ∈ Quot.mk Setoid.r []
hy : y ∈ Quot.mk Setoid.r []
⊢ 2 ≤ length (Quot.mk Setoid.r [])

tactic: simp only [mem_coe_iff, mk_eq_coe, mem_singleton] at hx hy
state_before: case intro.intro.intro.intro.h.cons.nil
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx✝ : x ∈ s
hy✝ : y ∈ s
hd : α
hx : x ∈ Quot.mk Setoid.r [hd]
hy : y ∈ Quot.mk Setoid.r [hd]
⊢ 2 ≤ length (Quot.mk Setoid.r [hd])

tactic: simp [hx, hy] at hxy
state_before: case intro.intro.intro.intro.h.cons.nil
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx✝ : x ∈ s
hy✝ : y ∈ s
hd : α
hx : x = hd
hy : y = hd
⊢ 2 ≤ length (Quot.mk Setoid.r [hd])

tactic: simp [Nat.succ_le_succ_iff]
state_before: case intro.intro.intro.intro.h.cons.cons
α : Type u_1
s : Cycle α
x y : α
hxy : x ≠ y
hx✝ : x ∈ s
hy✝ : y ∈ s
hd hd' : α
tl : List α
hx : x ∈ Quot.mk Setoid.r (hd :: hd' :: tl)
hy : y ∈ Quot.mk Setoid.r (hd :: hd' :: tl)
⊢ 2 ≤ length (Quot.mk Setoid.r (hd :: hd' :: tl))
Theorem: Ordinal.add_le_nadd
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: apply b.limitRecOn
state_before: a b c : Ordinal
⊢ a + b ≤ a ♯ b

tactic: simp
state_before: case H₁
a b c : Ordinal
⊢ a + 0 ≤ a ♯ 0

tactic: intro c h
state_before: case H₂
a b c : Ordinal
⊢ ∀ (o : Ordinal), a + o ≤ a ♯ o → a + succ o ≤ a ♯ succ o

tactic: rwa [add_succ, nadd_succ, succ_le_succ_iff]
state_before: case H₂
a b c✝ c : Ordinal
h : a + c ≤ a ♯ c
⊢ a + succ c ≤ a ♯ succ c

tactic: intro c hc H
state_before: case H₃
a b c : Ordinal
⊢ ∀ (o : Ordinal), IsLimit o → (∀ (o' : Ordinal), o' < o → a + o' ≤ a ♯ o') → a + o ≤ a ♯ o

tactic: simp_rw [← IsNormal.blsub_eq.{u, u} (add_isNormal a) hc, blsub_le_iff]
state_before: case H₃
a b c✝ c : Ordinal
hc : IsLimit c
H : ∀ (o' : Ordinal), o' < c → a + o' ≤ a ♯ o'
⊢ a + c ≤ a ♯ c

tactic: exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
state_before: case H₃
a b c✝ c : Ordinal
hc : IsLimit c
H : ∀ (o' : Ordinal), o' < c → a + o' ≤ a ♯ o'
⊢ ∀ (i : Ordinal), i < c → a + i < a ♯ c
Theorem: SemidirectProduct.mk_eq_inl_mul_inr
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext <;> simp
state_before: N : Type u_1
G : Type u_2
H : Type ?u.88833
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
g : G
n : N
⊢ { left := n, right := g } = ↑inl n * ↑inr g
Theorem: List.countp_go_eq_add
File: Mathlib/Data/List/Count.lean

tactic: induction' l with head tail ih generalizing n
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
n : ℕ
l : List α
⊢ countp.go p l n = n + countp.go p l 0

tactic: rfl
state_before: case nil
α : Type u_1
l : List α
p q : α → Bool
n✝ n : ℕ
⊢ countp.go p [] n = n + countp.go p [] 0

tactic: unfold countp.go
state_before: case cons
α : Type u_1
l : List α
p q : α → Bool
n✝ : ℕ
head : α
tail : List α
ih : ∀ {n : ℕ}, countp.go p tail n = n + countp.go p tail 0
n : ℕ
⊢ countp.go p (head :: tail) n = n + countp.go p (head :: tail) 0

tactic: rw [ih (n := n + 1), ih (n := n), ih (n := 1)]
state_before: case cons
α : Type u_1
l : List α
p q : α → Bool
n✝ : ℕ
head : α
tail : List α
ih : ∀ {n : ℕ}, countp.go p tail n = n + countp.go p tail 0
n : ℕ
⊢ (bif p head then countp.go p tail (n + 1) else countp.go p tail n) =
    n + bif p head then countp.go p tail (0 + 1) else countp.go p tail 0

tactic: by_cases h : p head
state_before: case cons
α : Type u_1
l : List α
p q : α → Bool
n✝ : ℕ
head : α
tail : List α
ih : ∀ {n : ℕ}, countp.go p tail n = n + countp.go p tail 0
n : ℕ
⊢ (bif p head then n + 1 + countp.go p tail 0 else n + countp.go p tail 0) =
    n + bif p head then 1 + countp.go p tail 0 else countp.go p tail 0

tactic: simp [h, add_assoc]
state_before: case pos
α : Type u_1
l : List α
p q : α → Bool
n✝ : ℕ
head : α
tail : List α
ih : ∀ {n : ℕ}, countp.go p tail n = n + countp.go p tail 0
n : ℕ
h : p head = true
⊢ (bif p head then n + 1 + countp.go p tail 0 else n + countp.go p tail 0) =
    n + bif p head then 1 + countp.go p tail 0 else countp.go p tail 0

tactic: simp [h]
state_before: case neg
α : Type u_1
l : List α
p q : α → Bool
n✝ : ℕ
head : α
tail : List α
ih : ∀ {n : ℕ}, countp.go p tail n = n + countp.go p tail 0
n : ℕ
h : ¬p head = true
⊢ (bif p head then n + 1 + countp.go p tail 0 else n + countp.go p tail 0) =
    n + bif p head then 1 + countp.go p tail 0 else countp.go p tail 0
Theorem: Equiv.Perm.SameCycle.cycleOf_eq
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: ext z
state_before: ι : Type ?u.2244324
α : Type u_1
β : Type ?u.2244330
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : SameCycle f x y
⊢ cycleOf f x = cycleOf f y

tactic: rw [Equiv.Perm.cycleOf_apply]
state_before: case H
ι : Type ?u.2244324
α : Type u_1
β : Type ?u.2244330
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : SameCycle f x y
z : α
⊢ ↑(cycleOf f x) z = ↑(cycleOf f y) z

tactic: split_ifs with hz
state_before: case H
ι : Type ?u.2244324
α : Type u_1
β : Type ?u.2244330
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : SameCycle f x y
z : α
⊢ (if SameCycle f x z then ↑f z else z) = ↑(cycleOf f y) z

tactic: exact (h.symm.trans hz).cycleOf_apply.symm
state_before: case H.inl
ι : Type ?u.2244324
α : Type u_1
β : Type ?u.2244330
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : SameCycle f x y
z : α
hz : SameCycle f x z
⊢ ↑f z = ↑(cycleOf f y) z

tactic: exact (cycleOf_apply_of_not_sameCycle (mt h.trans hz)).symm
state_before: case H.inr
ι : Type ?u.2244324
α : Type u_1
β : Type ?u.2244330
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : SameCycle f x y
z : α
hz : ¬SameCycle f x z
⊢ z = ↑(cycleOf f y) z
Theorem: Ordinal.CNF_snd_lt
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: refine' CNFRec b _ (fun o ho IH ↦ _) o
state_before: b o : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
⊢ x ∈ CNF b o → x.snd < b

tactic: simp only [CNF_zero, not_mem_nil, IsEmpty.forall_iff]
state_before: case refine'_1
b o : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
⊢ x ∈ CNF b 0 → x.snd < b

tactic: rw [CNF_ne_zero ho]
state_before: case refine'_2
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
⊢ x ∈ CNF b o → x.snd < b

tactic: intro h
state_before: case refine'_2
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
⊢ x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o) → x.snd < b

tactic: cases' (mem_cons.mp h) with h h
state_before: case refine'_2
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
h : x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o)
⊢ x.snd < b

tactic: rw [h]
state_before: case refine'_2.inl
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
h✝ : x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o)
h : x = (log b o, o / b ^ log b o)
⊢ x.snd < b

tactic: simpa only using div_opow_log_lt o hb
state_before: case refine'_2.inl
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
h✝ : x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o)
h : x = (log b o, o / b ^ log b o)
⊢ (log b o, o / b ^ log b o).snd < b

tactic: exact IH h
state_before: case refine'_2.inr
b o✝ : Ordinal
hb : 1 < b
x : Ordinal × Ordinal
o : Ordinal
ho : o ≠ 0
IH : x ∈ CNF b (o % b ^ log b o) → x.snd < b
h✝ : x ∈ (log b o, o / b ^ log b o) :: CNF b (o % b ^ log b o)
h : x ∈ CNF b (o % b ^ log b o)
⊢ x.snd < b
Theorem: Nat.Prime.five_le_of_ne_two_of_ne_three
File: Mathlib/Data/Nat/Prime.lean

tactic: by_contra' h
state_before: p : ℕ
hp : Prime p
h_two : p ≠ 2
h_three : p ≠ 3
⊢ 5 ≤ p

tactic: revert h_two h_three hp
state_before: p : ℕ
hp : Prime p
h_two : p ≠ 2
h_three : p ≠ 3
h : p < 5
⊢ False

tactic: match p with
| 0 => decide
| 1 => decide
| 2 => decide
| 3 => decide
| 4 => decide
| n + 5 => exact (h.not_le le_add_self).elim
state_before: p : ℕ
h : p < 5
⊢ Prime p → p ≠ 2 → p ≠ 3 → False

tactic: decide
state_before: p : ℕ
h : 0 < 5
⊢ Prime 0 → 0 ≠ 2 → 0 ≠ 3 → False

tactic: decide
state_before: p : ℕ
h : 1 < 5
⊢ Prime 1 → 1 ≠ 2 → 1 ≠ 3 → False

tactic: decide
state_before: p : ℕ
h : 2 < 5
⊢ Prime 2 → 2 ≠ 2 → 2 ≠ 3 → False

tactic: decide
state_before: p : ℕ
h : 3 < 5
⊢ Prime 3 → 3 ≠ 2 → 3 ≠ 3 → False

tactic: decide
state_before: p : ℕ
h : 4 < 5
⊢ Prime 4 → 4 ≠ 2 → 4 ≠ 3 → False

tactic: exact (h.not_le le_add_self).elim
state_before: p n : ℕ
h : n + 5 < 5
⊢ Prime (n + 5) → n + 5 ≠ 2 → n + 5 ≠ 3 → False
Theorem: Complex.zero_cpow_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: constructor
state_before: x a : ℂ
⊢ 0 ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: intro hyp
state_before: case mp
x a : ℂ
⊢ 0 ^ x = a → x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: simp only [cpow_def, eq_self_iff_true, if_true] at hyp
state_before: case mp
x a : ℂ
hyp : 0 ^ x = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: by_cases x = 0
state_before: case mp
x a : ℂ
hyp : (if x = 0 then 1 else 0) = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: subst h
state_before: case pos
x a : ℂ
hyp : (if x = 0 then 1 else 0) = a
h : x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: simp only [if_true, eq_self_iff_true] at hyp
state_before: case pos
a : ℂ
hyp : (if 0 = 0 then 1 else 0) = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1

tactic: right
state_before: case pos
a : ℂ
hyp : 1 = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1

tactic: exact ⟨rfl, hyp.symm⟩
state_before: case pos.h
a : ℂ
hyp : 1 = a
⊢ 0 = 0 ∧ a = 1

tactic: rw [if_neg h] at hyp
state_before: case neg
x a : ℂ
hyp : (if x = 0 then 1 else 0) = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: left
state_before: case neg
x a : ℂ
hyp : 0 = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: exact ⟨h, hyp.symm⟩
state_before: case neg.h
x a : ℂ
hyp : 0 = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0

tactic: rintro (⟨h, rfl⟩ | ⟨rfl, rfl⟩)
state_before: case mpr
x a : ℂ
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 → 0 ^ x = a

tactic: exact zero_cpow h
state_before: case mpr.inl.intro
x : ℂ
h : x ≠ 0
⊢ 0 ^ x = 0

tactic: exact cpow_zero _
state_before: case mpr.inr.intro

⊢ 0 ^ 0 = 1
Theorem: Finset.map_subtype_embedding_Ico
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [subtype_Ico_eq]
state_before: α : Type u_1
β : Type ?u.219517
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Ico a b) = Ico ↑a ↑b

tactic: refine' Finset.subtype_map_of_mem fun x hx => _
state_before: α : Type u_1
β : Type ?u.219517
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ico ↑a ↑b)) = Ico ↑a ↑b

tactic: rw [mem_Ico] at hx
state_before: α : Type u_1
β : Type ?u.219517
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ico ↑a ↑b
⊢ p x

tactic: exact hp hx.1 hx.2.le a.prop b.prop
state_before: α : Type u_1
β : Type ?u.219517
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a ≤ x ∧ x < ↑b
⊢ p x
Theorem: MeasureTheory.Measure.integral_comp_mul_right
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simpa only [mul_comm] using integral_comp_mul_left g a
state_before: E : Type ?u.94593
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
g : ℝ → F
a : ℝ
⊢ (∫ (x : ℝ), g (x * a)) = abs a⁻¹ • ∫ (y : ℝ), g y
Theorem: LinearPMap.inverse_domain
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rw [inverse, Submodule.toLinearPMap_domain, ← graph_map_snd_eq_range,
  ← LinearEquiv.fst_comp_prodComm, Submodule.map_comp]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_3
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.701262
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ (inverse hf).domain = LinearMap.range f.toFun

tactic: rfl
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_3
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.701262
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ Submodule.map (LinearMap.fst R F E) (Submodule.map (LinearEquiv.prodComm R E F) (graph f)) =
    Submodule.map (LinearMap.fst R F E) (Submodule.map (↑(LinearEquiv.prodComm R E F)) (graph f))
Theorem: CategoryTheory.Idempotents.whiskeringLeft_obj_preimage_app
File: Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean

tactic: rw [natTrans_eq]
state_before: C : Type u_3
D : Type u_4
E : Type ?u.84970
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
inst✝ : IsIdempotentComplete D
F G : Karoubi C ⥤ D
τ : toKaroubi C ⋙ F ⟶ toKaroubi C ⋙ G
P : Karoubi C
⊢ (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app P =
    F.map (decompId_i P) ≫ τ.app P.X ≫ G.map (decompId_p P)

tactic: congr 2
state_before: C : Type u_3
D : Type u_4
E : Type ?u.84970
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
inst✝ : IsIdempotentComplete D
F G : Karoubi C ⥤ D
τ : toKaroubi C ⋙ F ⟶ toKaroubi C ⋙ G
P : Karoubi C
⊢ F.map (decompId_i P) ≫
      (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app (Karoubi.mk P.X (𝟙 P.X)) ≫
        G.map (decompId_p P) =
    F.map (decompId_i P) ≫ τ.app P.X ≫ G.map (decompId_p P)

tactic: rw [← congr_app (((whiskeringLeft _ _ _).obj (toKaroubi _)).image_preimage τ) P.X]
state_before: case e_a.e_a
C : Type u_3
D : Type u_4
E : Type ?u.84970
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
inst✝ : IsIdempotentComplete D
F G : Karoubi C ⥤ D
τ : toKaroubi C ⋙ F ⟶ toKaroubi C ⋙ G
P : Karoubi C
⊢ (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app (Karoubi.mk P.X (𝟙 P.X)) = τ.app P.X

tactic: dsimp
state_before: case e_a.e_a
C : Type u_3
D : Type u_4
E : Type ?u.84970
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
inst✝ : IsIdempotentComplete D
F G : Karoubi C ⥤ D
τ : toKaroubi C ⋙ F ⟶ toKaroubi C ⋙ G
P : Karoubi C
⊢ (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app (Karoubi.mk P.X (𝟙 P.X)) =
    (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).map
          (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ)).app
      P.X

tactic: congr
state_before: case e_a.e_a
C : Type u_3
D : Type u_4
E : Type ?u.84970
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
inst✝ : IsIdempotentComplete D
F G : Karoubi C ⥤ D
τ : toKaroubi C ⋙ F ⟶ toKaroubi C ⋙ G
P : Karoubi C
⊢ (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app (Karoubi.mk P.X (𝟙 P.X)) =
    (((whiskeringLeft C (Karoubi C) D).obj (toKaroubi C)).preimage τ).app ((toKaroubi C).obj P.X)
Theorem: RelIso.toEquiv_injective
File: Mathlib/Order/RelIso/Basic.lean

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.70668
δ : Type ?u.70671
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e₁ : α ≃ β
o₁ : ∀ {a b : α}, s (↑e₁ a) (↑e₁ b) ↔ r a b
e₂ : α ≃ β
map_rel_iff'✝ : ∀ {a b : α}, s (↑e₂ a) (↑e₂ b) ↔ r a b
h : { toEquiv := e₁, map_rel_iff' := o₁ }.toEquiv = { toEquiv := e₂, map_rel_iff' := map_rel_iff'✝ }.toEquiv
⊢ { toEquiv := e₁, map_rel_iff' := o₁ } = { toEquiv := e₂, map_rel_iff' := map_rel_iff'✝ }
Theorem: GaloisConnection.upperBounds_l_image
File: Mathlib/Order/GaloisConnection.lean

tactic: simp [upperBounds, gc _ _]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.2715
a a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
s : Set α
b : β
⊢ b ∈ upperBounds (l '' s) ↔ b ∈ u ⁻¹' upperBounds s
Theorem: GeneralizedContinuedFraction.of_s_head_aux
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: rw [of, IntFractPair.seq1]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v✝ : K
n : ℕ
v : K
⊢ Stream'.Seq.get? (of v).s 0 = Option.bind (IntFractPair.stream v 1) (some ∘ fun p => { a := 1, b := ↑p.b })

tactic: simp only [of, Stream'.Seq.map_tail, Stream'.Seq.map, Stream'.Seq.tail, Stream'.Seq.head,
  Stream'.Seq.get?, Stream'.map]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v✝ : K
n : ℕ
v : K
⊢ Stream'.Seq.get?
      (match
          (IntFractPair.of v,
            Stream'.Seq.tail
              { val := IntFractPair.stream v, property := (_ : Stream'.IsSeq (IntFractPair.stream v)) }) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).s
      0 =
    Option.bind (IntFractPair.stream v 1) (some ∘ fun p => { a := 1, b := ↑p.b })

tactic: rw [← Stream'.nth_succ, Stream'.nth, Option.map]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v✝ : K
n : ℕ
v : K
⊢ Option.map (fun p => { a := 1, b := ↑p.b }) (Stream'.nth (Stream'.tail (IntFractPair.stream v)) 0) =
    Option.bind (IntFractPair.stream v 1) (some ∘ fun p => { a := 1, b := ↑p.b })

tactic: split <;> simp_all only [Option.some_bind, Option.none_bind, Function.comp_apply]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v✝ : K
n : ℕ
v : K
⊢ (match IntFractPair.stream v (Nat.succ 0) with
    | some x => some { a := 1, b := ↑x.b }
    | none => none) =
    Option.bind (IntFractPair.stream v 1) (some ∘ fun p => { a := 1, b := ↑p.b })