tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.haar.chaar_mem_clPrehaar
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: have := (Classical.choose_spec (nonempty_iInter_clPrehaar K₀)).2
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
V : OpenNhdsOf 1
⊢ chaar K₀ ∈ clPrehaar (↑K₀) V

tactic: rw [mem_iInter] at this
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
V : OpenNhdsOf 1
this :
  Classical.choose (_ : Set.Nonempty (haarProduct ↑K₀ ∩ ⋂ (V : OpenNhdsOf 1), clPrehaar (↑K₀) V)) ∈
    ⋂ (V : OpenNhdsOf 1), clPrehaar (↑K₀) V
⊢ chaar K₀ ∈ clPrehaar (↑K₀) V

tactic: exact this V
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
V : OpenNhdsOf 1
this :
  ∀ (i : OpenNhdsOf 1),
    Classical.choose (_ : Set.Nonempty (haarProduct ↑K₀ ∩ ⋂ (V : OpenNhdsOf 1), clPrehaar (↑K₀) V)) ∈ clPrehaar (↑K₀) i
⊢ chaar K₀ ∈ clPrehaar (↑K₀) V
Theorem: List.rdropWhile_concat
File: Mathlib/Data/List/Rdrop.lean

tactic: simp only [rdropWhile, dropWhile, reverse_append, reverse_singleton, singleton_append]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rdropWhile p (l ++ [x]) = if p x = true then rdropWhile p l else l ++ [x]

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ reverse
      (match p x with
      | true => dropWhile p (reverse l)
      | false => x :: reverse l) =
    if p x = true then reverse (dropWhile p (reverse l)) else l ++ [x]
Theorem: Computation.think_bind
File: Mathlib/Data/Seq/Computation.lean

tactic: simp [bind, Bind.f]
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
f : α → Computation β
⊢ destruct (bind (think c) f) = Sum.inr (bind c f)
Theorem: RingQuot.liftAlgHom_unique
File: Mathlib/Algebra/RingQuot.lean

tactic: ext
state_before: R : Type u₁
inst✝⁶ : Semiring R
S : Type u₂
inst✝⁵ : CommSemiring S
A : Type u₃
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
f : A →ₐ[S] B
s : A → A → Prop
w : ∀ ⦃x y : A⦄, s x y → ↑f x = ↑f y
g : RingQuot s →ₐ[S] B
h : AlgHom.comp g (mkAlgHom S s) = f
⊢ g = ↑(liftAlgHom S) { val := f, property := w }

tactic: simp [h]
state_before: case w.H
R : Type u₁
inst✝⁶ : Semiring R
S : Type u₂
inst✝⁵ : CommSemiring S
A : Type u₃
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
f : A →ₐ[S] B
s : A → A → Prop
w : ∀ ⦃x y : A⦄, s x y → ↑f x = ↑f y
g : RingQuot s →ₐ[S] B
h : AlgHom.comp g (mkAlgHom S s) = f
x✝ : A
⊢ ↑(AlgHom.comp g (mkAlgHom S s)) x✝ = ↑(AlgHom.comp (↑(liftAlgHom S) { val := f, property := w }) (mkAlgHom S s)) x✝
Theorem: IsUpperSet.mul_left
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (s * t)

tactic: exact isUpperSet_iUnion₂ fun x _ ↦ ht.smul
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (⋃ (a : α) (_ : a ∈ s), a • t)
Theorem: Ordinal.sSup_eq_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: congr
state_before: α : Type ?u.307782
β : Type ?u.307785
γ : Type ?u.307788
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ sSup (brange o f) = bsup o f

tactic: rw [range_familyOfBFamily]
state_before: case e_a
α : Type ?u.307782
β : Type ?u.307785
γ : Type ?u.307788
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ brange o f = range (familyOfBFamily o f)
Theorem: continuousWithinAt_Ico_iff_Iio
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Ico_eq_nhdsWithin_Iio h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
a✝ b✝ : α
inst✝ : TopologicalSpace γ
a b : α
f : α → γ
h : a < b
⊢ ContinuousWithinAt f (Ico a b) b ↔ ContinuousWithinAt f (Iio b) b
Theorem: AffineSubspace.wSameSide_iff_exists_right
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [wSameSide_comm, wSameSide_iff_exists_left h]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.242614
P : Type u_3
P' : Type ?u.242620
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ WSameSide s x y ↔ y ∈ s ∨ ∃ p₁, p₁ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

tactic: simp_rw [SameRay.sameRay_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.242614
P : Type u_3
P' : Type ?u.242620
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ (y ∈ s ∨ ∃ p₂_1, p₂_1 ∈ s ∧ SameRay R (y -ᵥ p₂) (x -ᵥ p₂_1)) ↔ y ∈ s ∨ ∃ p₁, p₁ ∈ s ∧ SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
Theorem: MeasureTheory.AEEqFun.integrable_iff_mem_L1
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← integrable_coeFn, ← memℒp_one_iff_integrable, Lp.mem_Lp_iff_memℒp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1265765
δ : Type ?u.1265768
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α →ₘ[μ] β
⊢ Integrable f ↔ f ∈ Lp β 1
Theorem: List.get_append_left
File: src/lean/Init/Data/List/BasicAux.lean

tactic: induction as generalizing i with
| nil => trivial
| cons a as ih =>
  cases i with
  | zero => rfl
  | succ i => apply ih
state_before: α : Type u_1
i : Nat
as bs : List α
h : i < length as
h' : i < length (as ++ bs)
⊢ get (as ++ bs) { val := i, isLt := h' } = get as { val := i, isLt := h }

tactic: trivial
state_before: case nil
α : Type u_1
bs : List α
i : Nat
h : i < length []
h' : i < length ([] ++ bs)
⊢ get ([] ++ bs) { val := i, isLt := h' } = get [] { val := i, isLt := h }

tactic: cases i with
| zero => rfl
| succ i => apply ih
state_before: case cons
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat} (h : i < length as) {h' : i < length (as ++ bs)},
    get (as ++ bs) { val := i, isLt := h' } = get as { val := i, isLt := h }
i : Nat
h : i < length (a :: as)
h' : i < length (a :: as ++ bs)
⊢ get (a :: as ++ bs) { val := i, isLt := h' } = get (a :: as) { val := i, isLt := h }

tactic: rfl
state_before: case cons.zero
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat} (h : i < length as) {h' : i < length (as ++ bs)},
    get (as ++ bs) { val := i, isLt := h' } = get as { val := i, isLt := h }
h : Nat.zero < length (a :: as)
h' : Nat.zero < length (a :: as ++ bs)
⊢ get (a :: as ++ bs) { val := Nat.zero, isLt := h' } = get (a :: as) { val := Nat.zero, isLt := h }

tactic: apply ih
state_before: case cons.succ
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat} (h : i < length as) {h' : i < length (as ++ bs)},
    get (as ++ bs) { val := i, isLt := h' } = get as { val := i, isLt := h }
i : Nat
h : Nat.succ i < length (a :: as)
h' : Nat.succ i < length (a :: as ++ bs)
⊢ get (a :: as ++ bs) { val := Nat.succ i, isLt := h' } = get (a :: as) { val := Nat.succ i, isLt := h }
Theorem: Pmf.mem_support_map_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.29641
f : α → β
p : Pmf α
b : β
⊢ b ∈ support (map f p) ↔ ∃ a, a ∈ support p ∧ f a = b
Theorem: SimpleGraph.Subgraph.degree_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [← card_neighborSet_eq_degree]
state_before: ι : Sort ?u.200951
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : V
inst✝¹ : Fintype ↑(neighborSet G' v)
inst✝ : Fintype ↑(SimpleGraph.neighborSet G v)
⊢ degree G' v ≤ SimpleGraph.degree G v

tactic: exact Set.card_le_of_subset (G'.neighborSet_subset v)
state_before: ι : Sort ?u.200951
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : V
inst✝¹ : Fintype ↑(neighborSet G' v)
inst✝ : Fintype ↑(SimpleGraph.neighborSet G v)
⊢ degree G' v ≤ Fintype.card ↑(SimpleGraph.neighborSet G v)
Theorem: Mathlib.Tactic.Abel.term_add_term
File: Mathlib/Tactic/Abel.lean

tactic: simp [h₁.symm, h₂.symm, term, add_nsmul, add_assoc, add_left_comm]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
n₁ : ℕ
x a₁ : α
n₂ : ℕ
a₂ : α
n' : ℕ
a' : α
h₁ : n₁ + n₂ = n'
h₂ : a₁ + a₂ = a'
⊢ term n₁ x a₁ + term n₂ x a₂ = term n' x a'
Theorem: Finsupp.erase_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext s
state_before: α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
⊢ erase a (single a b) = 0

tactic: by_cases hs : s = a
state_before: case h
α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
s : α
⊢ ↑(erase a (single a b)) s = ↑0 s

tactic: rw [hs, erase_same]
state_before: case pos
α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
s : α
hs : s = a
⊢ ↑(erase a (single a b)) s = ↑0 s

tactic: rfl
state_before: case pos
α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
s : α
hs : s = a
⊢ 0 = ↑0 a

tactic: rw [erase_ne hs]
state_before: case neg
α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
s : α
hs : ¬s = a
⊢ ↑(erase a (single a b)) s = ↑0 s

tactic: exact single_eq_of_ne (Ne.symm hs)
state_before: case neg
α : Type u_1
β : Type ?u.165062
γ : Type ?u.165065
ι : Type ?u.165068
M : Type u_2
M' : Type ?u.165074
N : Type ?u.165077
P : Type ?u.165080
G : Type ?u.165083
H : Type ?u.165086
R : Type ?u.165089
S : Type ?u.165092
inst✝ : Zero M
a : α
b : M
s : α
hs : ¬s = a
⊢ ↑(single a b) s = ↑0 s
Theorem: Metric.mem_thickening_iff
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: have key_iff : ∀ z : X, edist x z < ENNReal.ofReal δ ↔ dist x z < δ := fun z ↦ by
  rw [dist_edist, lt_ofReal_iff_toReal_lt (edist_ne_top _ _)]
state_before: ι : Sort ?u.94466
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x : X
⊢ x ∈ thickening δ E ↔ ∃ z, z ∈ E ∧ dist x z < δ

tactic: simp_rw [mem_thickening_iff_exists_edist_lt, key_iff]
state_before: ι : Sort ?u.94466
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x : X
key_iff : ∀ (z : X), edist x z < ENNReal.ofReal δ ↔ dist x z < δ
⊢ x ∈ thickening δ E ↔ ∃ z, z ∈ E ∧ dist x z < δ

tactic: rw [dist_edist, lt_ofReal_iff_toReal_lt (edist_ne_top _ _)]
state_before: ι : Sort ?u.94466
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x z : X
⊢ edist x z < ENNReal.ofReal δ ↔ dist x z < δ
Theorem: PNat.div_coe
File: Mathlib/Data/PNat/Defs.lean

tactic: dsimp [div, modDiv]
state_before: m k : ℕ+
⊢ div m k = if ↑m % ↑k = 0 then pred (↑m / ↑k) else ↑m / ↑k

tactic: cases (m : ℕ) % (k : ℕ) with
| zero =>
  rw [if_pos rfl]
  rfl
| succ n =>
  rw [if_neg n.succ_ne_zero]
  rfl
state_before: m k : ℕ+
⊢ (modDivAux k (↑m % ↑k) (↑m / ↑k)).snd = if ↑m % ↑k = 0 then pred (↑m / ↑k) else ↑m / ↑k

tactic: rw [if_pos rfl]
state_before: case zero
m k : ℕ+
⊢ (modDivAux k zero (↑m / ↑k)).snd = if zero = 0 then pred (↑m / ↑k) else ↑m / ↑k

tactic: rfl
state_before: case zero
m k : ℕ+
⊢ (modDivAux k zero (↑m / ↑k)).snd = pred (↑m / ↑k)

tactic: rw [if_neg n.succ_ne_zero]
state_before: case succ
m k : ℕ+
n : ℕ
⊢ (modDivAux k (succ n) (↑m / ↑k)).snd = if succ n = 0 then pred (↑m / ↑k) else ↑m / ↑k

tactic: rfl
state_before: case succ
m k : ℕ+
n : ℕ
⊢ (modDivAux k (succ n) (↑m / ↑k)).snd = ↑m / ↑k
Theorem: Orthonormal.ne_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: have : ‖v i‖ ≠ 0 := by
  rw [hv.1 i]
  norm_num
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2164084
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
i : ι
⊢ v i ≠ 0

tactic: simpa using this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2164084
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
i : ι
this : ‖v i‖ ≠ 0
⊢ v i ≠ 0

tactic: rw [hv.1 i]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2164084
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
i : ι
⊢ ‖v i‖ ≠ 0

tactic: norm_num
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2164084
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
i : ι
⊢ 1 ≠ 0
Theorem: toIocDiv_eq_neg_floor
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine' toIocDiv_eq_of_sub_zsmul_mem_Ioc hp _
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ toIocDiv hp a b = -⌊(a + p - b) / p⌋

tactic: rw [Set.mem_Ioc, zsmul_eq_mul, Int.cast_neg, neg_mul, sub_neg_eq_add, ← sub_nonneg,
  sub_add_eq_sub_sub]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - -⌊(a + p - b) / p⌋ • p ∈ Set.Ioc a (a + p)

tactic: refine' ⟨_, Int.sub_floor_div_mul_nonneg _ hp⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ a < b + ↑⌊(a + p - b) / p⌋ * p ∧ 0 ≤ a + p - b - ↑⌊(a + p - b) / p⌋ * p

tactic: rw [← add_lt_add_iff_right p, add_assoc, add_comm b, ← sub_lt_iff_lt_add, add_comm (_ * _), ←
  sub_lt_iff_lt_add]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ a < b + ↑⌊(a + p - b) / p⌋ * p

tactic: exact Int.sub_floor_div_mul_lt _ hp
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ a + p - b - ↑⌊(a + p - b) / p⌋ * p < p
Theorem: Array.get?_set_ne
File: Std/Data/Array/Lemmas.lean

tactic: by_cases j < a.size <;> simp [getElem?_pos, getElem?_neg, *]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
j : Nat
v : α
h : i.val ≠ j
⊢ (set a i v)[j]? = a[j]?
Theorem: RegularExpression.matches'_map
File: Mathlib/Computability/RegularExpressions.lean

tactic: rw [eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a✝ b : α
f : α → β
a : α
⊢ matches' (map f (char a)) = ↑(Language.map f) (matches' (char a))

tactic: exact image_singleton
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a✝ b : α
f : α → β
a : α
⊢ ↑(Language.map f) (matches' (char a)) = matches' (map f (char a))

tactic: simp only [matches'_map, map, matches'_add]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R S : RegularExpression α
⊢ matches' (map f (R + S)) = ↑(Language.map f) (matches' (R + S))

tactic: rw [map_add]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R S : RegularExpression α
⊢ ↑(Language.map f) (matches' R) + ↑(Language.map f) (matches' S) = ↑(Language.map f) (matches' R + matches' S)

tactic: simp only [matches'_map, map, matches'_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R S : RegularExpression α
⊢ matches' (map f (R * S)) = ↑(Language.map f) (matches' (R * S))

tactic: rw [map_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R S : RegularExpression α
⊢ ↑(Language.map f) (matches' R) * ↑(Language.map f) (matches' S) = ↑(Language.map f) (matches' R * matches' S)

tactic: simp_rw [map, matches', matches'_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R : RegularExpression α
⊢ matches' (map f (star R)) = ↑(Language.map f) (matches' (star R))

tactic: rw [Language.kstar_eq_iSup_pow, Language.kstar_eq_iSup_pow]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R : RegularExpression α
⊢ (↑(Language.map f) (matches' R))∗ = ↑(Language.map f) (matches' R)∗

tactic: simp_rw [← map_pow]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R : RegularExpression α
⊢ (⨆ (i : ℕ), ↑(Language.map f) (matches' R) ^ i) = ↑(Language.map f) (⨆ (i : ℕ), matches' R ^ i)

tactic: exact image_iUnion.symm
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.138072
dec : DecidableEq α
a b : α
f : α → β
R : RegularExpression α
⊢ (⨆ (i : ℕ), ↑(Language.map f) (matches' R ^ i)) = ↑(Language.map f) (⨆ (i : ℕ), matches' R ^ i)
Theorem: Metric.closure_eq_iInter_cthickening'
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: by_cases hs₀ : s ⊆ Ioi 0
state_before: ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
⊢ closure E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: obtain ⟨δ, hδs, δ_nonpos⟩ := not_subset.mp hs₀
state_before: case neg
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
⊢ closure E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: rw [Set.mem_Ioi, not_lt] at δ_nonpos
state_before: case neg.intro.intro
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
δ : ℝ
hδs : δ ∈ s
δ_nonpos : ¬δ ∈ Ioi 0
⊢ closure E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: apply Subset.antisymm
state_before: case neg.intro.intro
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
δ : ℝ
hδs : δ ∈ s
δ_nonpos : δ ≤ 0
⊢ closure E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: rw [← cthickening_zero]
state_before: case pos
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : s ⊆ Ioi 0
⊢ closure E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: apply cthickening_eq_iInter_cthickening' _ hs₀ hs
state_before: case pos
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : s ⊆ Ioi 0
⊢ cthickening 0 E = ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: exact subset_iInter₂ fun ε _ => closure_subset_cthickening ε E
state_before: case neg.intro.intro.h₁
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
δ : ℝ
hδs : δ ∈ s
δ_nonpos : δ ≤ 0
⊢ closure E ⊆ ⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E

tactic: rw [← cthickening_of_nonpos δ_nonpos E]
state_before: case neg.intro.intro.h₂
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
δ : ℝ
hδs : δ ∈ s
δ_nonpos : δ ≤ 0
⊢ (⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E) ⊆ closure E

tactic: exact biInter_subset_of_mem hδs
state_before: case neg.intro.intro.h₂
ι : Sort ?u.143633
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
E : Set α
s : Set ℝ
hs : ∀ (ε : ℝ), 0 < ε → Set.Nonempty (s ∩ Ioc 0 ε)
hs₀ : ¬s ⊆ Ioi 0
δ : ℝ
hδs : δ ∈ s
δ_nonpos : δ ≤ 0
⊢ (⋂ (δ : ℝ) (_ : δ ∈ s), cthickening δ E) ⊆ cthickening δ E
Theorem: eq_of_prime_pow_eq'
File: Mathlib/Algebra/Associated.lean

tactic: rw [← associated_iff_eq] at h⊢
state_before: α : Type ?u.254209
β : Type ?u.254212
γ : Type ?u.254215
δ : Type ?u.254218
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : Unique Rˣ
p₁ p₂ : R
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₂
h : p₁ ^ k₁ = p₂ ^ k₂
⊢ p₁ = p₂

tactic: apply h.of_pow_associated_of_prime' hp₁ hp₂ hk₁
state_before: α : Type ?u.254209
β : Type ?u.254212
γ : Type ?u.254215
δ : Type ?u.254218
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : Unique Rˣ
p₁ p₂ : R
k₁ k₂ : ℕ
hp₁ : Prime p₁
hp₂ : Prime p₂
hk₁ : 0 < k₂
h✝ : p₁ ^ k₁ = p₂ ^ k₂
h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂
⊢ p₁ ~ᵤ p₂
Theorem: Finsupp.mapRange_add
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [hf', add_apply, mapRange_apply]
state_before: α : Type u_3
β : Type ?u.376063
γ : Type ?u.376066
ι : Type ?u.376069
M : Type u_2
M' : Type ?u.376075
N : Type u_1
P : Type ?u.376081
G : Type ?u.376084
H : Type ?u.376087
R : Type ?u.376090
S : Type ?u.376093
inst✝¹ : AddZeroClass M
inst✝ : AddZeroClass N
f : M → N
hf : f 0 = 0
hf' : ∀ (x y : M), f (x + y) = f x + f y
v₁ v₂ : α →₀ M
x✝ : α
⊢ ↑(mapRange f hf (v₁ + v₂)) x✝ = ↑(mapRange f hf v₁ + mapRange f hf v₂) x✝