tasksource/leandojo huggingface dataset:
Theorem: Language.map_map
File: Mathlib/Computability/Language.lean

tactic: simp [map, image_image]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
l✝ m : Language α
a b x : List α
g : β → γ
f : α → β
l : Language α
⊢ ↑(map g) (↑(map f) l) = ↑(map (g ∘ f)) l
Theorem: Complex.sameRay_iff_arg_div_eq_zero
File: Mathlib/Analysis/Complex/Arg.lean

tactic: rw [← Real.Angle.toReal_zero, ← arg_coe_angle_eq_iff_eq_toReal, sameRay_iff]
state_before: x y : ℂ
⊢ SameRay ℝ x y ↔ arg (x / y) = 0

tactic: by_cases hx : x = 0
state_before: x y : ℂ
⊢ x = 0 ∨ y = 0 ∨ arg x = arg y ↔ ↑(arg (x / y)) = 0

tactic: by_cases hy : y = 0
state_before: case neg
x y : ℂ
hx : ¬x = 0
⊢ x = 0 ∨ y = 0 ∨ arg x = arg y ↔ ↑(arg (x / y)) = 0

tactic: simp [hx, hy, arg_div_coe_angle, sub_eq_zero]
state_before: case neg
x y : ℂ
hx : ¬x = 0
hy : ¬y = 0
⊢ x = 0 ∨ y = 0 ∨ arg x = arg y ↔ ↑(arg (x / y)) = 0

tactic: simp [hx]
state_before: case pos
x y : ℂ
hx : x = 0
⊢ x = 0 ∨ y = 0 ∨ arg x = arg y ↔ ↑(arg (x / y)) = 0

tactic: simp [hy]
state_before: case pos
x y : ℂ
hx : ¬x = 0
hy : y = 0
⊢ x = 0 ∨ y = 0 ∨ arg x = arg y ↔ ↑(arg (x / y)) = 0
Theorem: rank_fun
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [rank_pi, Cardinal.sum_const', Cardinal.mk_fintype]
state_before: K : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η✝ : Type u₁'
φ : η✝ → Type ?u.526682
inst✝¹⁸ : Ring K
inst✝¹⁷ : StrongRankCondition K
inst✝¹⁶ : AddCommGroup V✝
inst✝¹⁵ : Module K V✝
inst✝¹⁴ : Module.Free K V✝
inst✝¹³ : AddCommGroup V'
inst✝¹² : Module K V'
inst✝¹¹ : Module.Free K V'
inst✝¹⁰ : AddCommGroup V₁
inst✝⁹ : Module K V₁
inst✝⁸ : Module.Free K V₁
inst✝⁷ : (i : η✝) → AddCommGroup (φ i)
inst✝⁶ : (i : η✝) → Module K (φ i)
inst✝⁵ : ∀ (i : η✝), Module.Free K (φ i)
inst✝⁴ : Fintype η✝
V η : Type u
inst✝³ : Fintype η
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ Module.rank K (η → V) = ↑(Fintype.card η) * Module.rank K V
Theorem: Rat.mul_den_eq_num
File: Mathlib/Data/Rat/Lemmas.lean

tactic: suffices (q.num /. ↑q.den) * (↑q.den /. 1) = q.num /. 1 by
  conv => pattern (occs := 1)q ; (rw [← @num_den q])
  simp only [coe_int_eq_divInt, coe_nat_eq_divInt, num_den] at this ⊢; assumption
state_before: q : ℚ
⊢ q * ↑q.den = ↑q.num

tactic: have : (q.den : ℤ) ≠ 0 := ne_of_gt (by exact_mod_cast q.pos)
state_before: q : ℚ
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1

tactic: rw [Rat.mul_def' this one_ne_zero, mul_comm (q.den : ℤ) 1, divInt_mul_right this]
state_before: q : ℚ
this : ↑q.den ≠ 0
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1

tactic: conv => pattern (occs := 1)q ; (rw [← @num_den q])
state_before: q : ℚ
this : q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
⊢ q * ↑q.den = ↑q.num

tactic: simp only [coe_int_eq_divInt, coe_nat_eq_divInt, num_den] at this ⊢
state_before: q : ℚ
this : q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
⊢ q.num /. ↑q.den * ↑q.den = ↑q.num

tactic: assumption
state_before: q : ℚ
this : q * (↑q.den /. 1) = q.num /. 1
⊢ q * (↑q.den /. 1) = q.num /. 1

tactic: exact_mod_cast q.pos
state_before: q : ℚ
⊢ 0 < ↑q.den
Theorem: totallyBounded_iff_ultrafilter
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine' ⟨fun hs f => f.cauchy_of_totallyBounded hs, fun H => totallyBounded_iff_filter.2 _⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ TotallyBounded s ↔ ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → Cauchy ↑f

tactic: intro f hf hfs
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → Cauchy ↑f
⊢ ∀ (f : Filter α), NeBot f → f ≤ 𝓟 s → ∃ c, c ≤ f ∧ Cauchy c

tactic: exact ⟨Ultrafilter.of f, Ultrafilter.of_le f, H _ ((Ultrafilter.of_le f).trans hfs)⟩
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → Cauchy ↑f
f : Filter α
hf : NeBot f
hfs : f ≤ 𝓟 s
⊢ ∃ c, c ≤ f ∧ Cauchy c
Theorem: PFunctor.M.children_mk
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: rw [head_mk]
state_before: F : PFunctor
X : Type ?u.26665
f : X → Obj F X
a : F.A
x : B F a → M F
i : B F (head (M.mk { fst := a, snd := x }))
⊢ B F (head (M.mk { fst := a, snd := x })) = B F a

tactic: apply ext'
state_before: F : PFunctor
X : Type ?u.26665
f : X → Obj F X
a : F.A
x : B F a → M F
i : B F (head (M.mk { fst := a, snd := x }))
⊢ children (M.mk { fst := a, snd := x }) i = x (cast (_ : B F (head (M.mk { fst := a, snd := x })) = B F a) i)

tactic: intro n
state_before: case H
F : PFunctor
X : Type ?u.26665
f : X → Obj F X
a : F.A
x : B F a → M F
i : B F (head (M.mk { fst := a, snd := x }))
⊢ ∀ (i_1 : ℕ),
    MIntl.approx (children (M.mk { fst := a, snd := x }) i) i_1 =
      MIntl.approx (x (cast (_ : B F (head (M.mk { fst := a, snd := x })) = B F a) i)) i_1

tactic: rfl
state_before: case H
F : PFunctor
X : Type ?u.26665
f : X → Obj F X
a : F.A
x : B F a → M F
i : B F (head (M.mk { fst := a, snd := x }))
n : ℕ
⊢ MIntl.approx (children (M.mk { fst := a, snd := x }) i) n =
    MIntl.approx (x (cast (_ : B F (head (M.mk { fst := a, snd := x })) = B F a) i)) n
Theorem: List.zipLeft_nil_right
File: Mathlib/Data/List/Basic.lean

tactic: cases as <;> rfl
state_before: ι : Type ?u.476599
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ zipLeft as [] = map (fun a => (a, none)) as
Theorem: Set.projIcc_eq_left
File: Mathlib/Data/Set/Intervals/ProjIcc.lean

tactic: refine' ⟨fun h' => _, projIcc_of_le_left _⟩
state_before: α : Type u_1
β : Type ?u.3590
inst✝ : LinearOrder α
a b : α
h✝ : a ≤ b
x : α
h : a < b
⊢ projIcc a b (_ : a ≤ b) x = { val := a, property := (_ : a ∈ Icc a b) } ↔ x ≤ a

tactic: simp_rw [Subtype.ext_iff_val, projIcc, max_eq_left_iff, min_le_iff, h.not_le, false_or_iff] at h'
state_before: α : Type u_1
β : Type ?u.3590
inst✝ : LinearOrder α
a b : α
h✝ : a ≤ b
x : α
h : a < b
h' : projIcc a b (_ : a ≤ b) x = { val := a, property := (_ : a ∈ Icc a b) }
⊢ x ≤ a

tactic: exact h'
state_before: α : Type u_1
β : Type ?u.3590
inst✝ : LinearOrder α
a b : α
h✝ : a ≤ b
x : α
h : a < b
h' : x ≤ a
⊢ x ≤ a
Theorem: Filter.map_pi_map_coprodᵢ_le
File: Mathlib/Order/Filter/Pi.lean

tactic: simp only [le_def, mem_map, mem_coprodᵢ_iff]
state_before: ι : Type u_1
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
β : ι → Type u_2
m : (i : ι) → α i → β i
⊢ map (fun k i => m i (k i)) (Filter.coprodᵢ f) ≤ Filter.coprodᵢ fun i => map (m i) (f i)

tactic: intro s h i
state_before: ι : Type u_1
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
β : ι → Type u_2
m : (i : ι) → α i → β i
⊢ ∀ (x : Set ((i : ι) → β i)),
    (∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ x) →
      ∀ (i : ι), ∃ t₁, t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' x

tactic: obtain ⟨t, H, hH⟩ := h i
state_before: ι : Type u_1
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
β : ι → Type u_2
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
⊢ ∃ t₁, t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s

tactic: exact ⟨{ x : α i | m i x ∈ t }, H, fun x hx => hH hx⟩
state_before: case intro.intro
ι : Type u_1
α : ι → Type u_3
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
β : ι → Type u_2
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
t : Set (β i)
H : m i ⁻¹' t ∈ f i
hH : eval i ⁻¹' t ⊆ s
⊢ ∃ t₁, t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
Theorem: SimpleGraph.Walk.map_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
hu : u = u'
hv : v = v'
⊢ Walk.map f (Walk.copy p hu hv) = Walk.copy (Walk.map f p) (_ : ↑f u = ↑f u') (_ : ↑f v = ↑f v')

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u' v' : V
p : Walk G u' v'
⊢ Walk.map f (Walk.copy p (_ : u' = u') (_ : v' = v')) =
    Walk.copy (Walk.map f p) (_ : ↑f u' = ↑f u') (_ : ↑f v' = ↑f v')
Theorem: Traversable.traverse_map'
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → β
h : β → G γ
⊢ traverse (h ∘ g) = traverse h ∘ map g

tactic: rw [comp_apply, traverse_map]
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → β
h : β → G γ
x✝ : t α
⊢ traverse (h ∘ g) x✝ = (traverse h ∘ map g) x✝
Theorem: Submonoid.LocalizationMap.mk'_spec
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_assoc, mul_comm _ (f.toMap y), ← mul_assoc, mul_inv_left, mul_comm]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.742376
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ ↑(toMap f) x *
        ↑(↑(IsUnit.liftRight (MonoidHom.restrict (toMap f) S) (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(toMap f) ↑y)))
              y)⁻¹ *
      ↑(toMap f) ↑y =
    ↑(toMap f) x
Theorem: Metric.eq_of_glueDist_eq_zero
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: rw [eq_of_dist_eq_zero h]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x y : X
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inl y) = 0
⊢ Sum.inl x = Sum.inl y

tactic: exfalso
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : X
y : Y
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) = 0
⊢ Sum.inl x = Sum.inr y

tactic: linarith [le_glueDist_inl_inr Φ Ψ ε x y]
state_before: case h
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : X
y : Y
h : glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) = 0
⊢ False

tactic: exfalso
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : Y
y : X
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y) = 0
⊢ Sum.inr x = Sum.inl y

tactic: linarith [le_glueDist_inr_inl Φ Ψ ε x y]
state_before: case h
X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x : Y
y : X
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inl y) = 0
⊢ False

tactic: rw [eq_of_dist_eq_zero h]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
ε0 : 0 < ε
x y : Y
h : glueDist Φ Ψ ε (Sum.inr x) (Sum.inr y) = 0
⊢ Sum.inr x = Sum.inr y
Theorem: Int.preimage_Ico
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.238645
α : Type u_1
β : Type ?u.238651
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ Int.cast ⁻¹' Ico a b = Ico ⌈a⌉ ⌈b⌉

tactic: simp [ceil_le, lt_ceil]
state_before: case h
F : Type ?u.238645
α : Type u_1
β : Type ?u.238651
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ico a b ↔ x✝ ∈ Ico ⌈a⌉ ⌈b⌉
Theorem: hasFDerivWithinAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_hasFDerivWithinAt_iff, hasFDerivWithinAt_pi']
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ HasFDerivWithinAt f f' t y ↔ ∀ (i : ι), HasFDerivWithinAt (fun x => f x i) (comp (EuclideanSpace.proj i) f') t y

tactic: rfl
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι),
      HasFDerivWithinAt (fun x => (↑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i)
        (comp (proj i) (comp (↑(EuclideanSpace.equiv ι 𝕜)) f')) t y) ↔
    ∀ (i : ι), HasFDerivWithinAt (fun x => f x i) (comp (EuclideanSpace.proj i) f') t y
Theorem: Finset.sym_inter
File: Mathlib/Data/Finset/Sym.lean

tactic: ext m
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ t✝ : Finset α
a b : α
n✝ : ℕ
m : Sym α n✝
s t : Finset α
n : ℕ
⊢ Finset.sym (s ∩ t) n = Finset.sym s n ∩ Finset.sym t n

tactic: simp only [mem_inter, mem_sym_iff, imp_and, forall_and]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
s✝ t✝ : Finset α
a b : α
n✝ : ℕ
m✝ : Sym α n✝
s t : Finset α
n : ℕ
m : Sym α n
⊢ m ∈ Finset.sym (s ∩ t) n ↔ m ∈ Finset.sym s n ∩ Finset.sym t n
Theorem: UniqueFactorizationMonoid.factors_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [factors, dif_neg ane0]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Multiset.prod (factors a) ~ᵤ a

tactic: exact (Classical.choose_spec (exists_prime_factors a ane0)).2
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Multiset.prod (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a)) ~ᵤ a
Theorem: TopCat.Presheaf.stalkSpecializes_comp
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: simp
state_before: C✝ : Type u
inst✝³ : Category C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
C : Type u_1
inst✝¹ : Category C
inst✝ : HasColimits C
X : TopCat
F : Presheaf C X
x y z : ↑X
h : x ⤳ y
h' : y ⤳ z
x✝¹ : Opens ↑X
x✝ : z ∈ x✝¹
⊢ germ F { val := z, property := x✝ } ≫ stalkSpecializes F h' ≫ stalkSpecializes F h =
    germ F { val := z, property := x✝ } ≫ stalkSpecializes F (_ : x ⤳ z)
Theorem: Set.Iio_union_Ioo
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total c d with hcd hcd <;> simp [hcd] at h
state_before: α : Type u_1
β : Type ?u.106002
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : min c d < b
⊢ Iio b ∪ Ioo c d = Iio (max b d)

tactic: exact Iio_union_Ioo' h
state_before: case inl
α : Type u_1
β : Type ?u.106002
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c < b
⊢ Iio b ∪ Ioo c d = Iio (max b d)

tactic: rw [max_comm]
state_before: case inr
α : Type u_1
β : Type ?u.106002
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d < b
⊢ Iio b ∪ Ioo c d = Iio (max b d)

tactic: simp [*, max_eq_right_of_lt h]
state_before: case inr
α : Type u_1
β : Type ?u.106002
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d < b
⊢ Iio b ∪ Ioo c d = Iio (max d b)
Theorem: Function.Semiconj.injOn_image
File: Mathlib/Data/Set/Function.lean

tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ H
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.111902
ι : Sort ?u.111905
π : α → Type ?u.111910
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : InjOn fa s
hf : InjOn f (fa '' s)
⊢ InjOn fb (f '' s)

tactic: simp only [← h.eq] at H
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.111902
ι : Sort ?u.111905
π : α → Type ?u.111910
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : InjOn fa s
hf : InjOn f (fa '' s)
x : α
hx : x ∈ s
y : α
hy : y ∈ s
H : fb (f x) = fb (f y)
⊢ f x = f y

tactic: exact congr_arg f (ha hx hy <| hf (mem_image_of_mem fa hx) (mem_image_of_mem fa hy) H)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.111902
ι : Sort ?u.111905
π : α → Type ?u.111910
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : InjOn fa s
hf : InjOn f (fa '' s)
x : α
hx : x ∈ s
y : α
hy : y ∈ s
H : f (fa x) = f (fa y)
⊢ f x = f y
Theorem: MeasureTheory.measure_preimage_mul
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: rw [map_mul_left_eq_self μ g]
state_before: 𝕜 : Type ?u.369584
G : Type u_1
H : Type ?u.369590
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
g : G
A : Set G
⊢ ↑↑(Measure.map (fun h => g * h) μ) A = ↑↑μ A
Theorem: TensorAlgebra.ι_leftInverse
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: simp [ιInv, (AlgHom.toLinearMap_apply), toTrivSqZeroExt_ι _]
state_before: R : Type u_2
inst✝² : CommSemiring R
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
⊢ ↑ιInv (↑(ι R) x) = x
Theorem: Field.closure_subset
File: Mathlib/Deprecated/Subfield.lean

tactic: rintro _ ⟨p, hp, q, hq, hq0, rfl⟩
state_before: F : Type u_1
inst✝ : Field F
S T : Set F
hT : IsSubfield T
H : S ⊆ T
⊢ closure S ⊆ T

tactic: exact hT.div_mem (Ring.closure_subset hT.toIsSubring H hp)
  (Ring.closure_subset hT.toIsSubring H hq)
state_before: case intro.intro.intro.intro.refl
F : Type u_1
inst✝ : Field F
S T : Set F
hT : IsSubfield T
H : S ⊆ T
p : F
hp : p ∈ Ring.closure S
q : F
hq : q ∈ Ring.closure S
⊢ p / q ∈ T
Theorem: LinearMap.iterate_succ
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [pow_succ', mul_eq_comp]
state_before: R : Type u_2
R₁ : Type ?u.170956
R₂ : Type ?u.170959
R₃ : Type ?u.170962
R₄ : Type ?u.170965
S : Type ?u.170968
K : Type ?u.170971
K₂ : Type ?u.170974
M : Type u_1
M' : Type ?u.170980
M₁ : Type ?u.170983
M₂ : Type ?u.170986
M₃ : Type ?u.170989
M₄ : Type ?u.170992
N : Type ?u.170995
N₂ : Type ?u.170998
ι : Type ?u.171001
V : Type ?u.171004
V₂ : Type ?u.171007
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
n : ℕ
⊢ f' ^ (n + 1) = comp (f' ^ n) f'
Theorem: iteratedFDerivWithin_succ_eq_comp_right
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: ext m
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ iteratedFDerivWithin 𝕜 (n + 1) f s x =
    (↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f s y) s) x

tactic: rw [iteratedFDerivWithin_succ_apply_right hs hx]
state_before: case H
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
m : Fin (n + 1) → E
⊢ ↑(iteratedFDerivWithin 𝕜 (n + 1) f s x) m =
    ↑((↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f s y) s) x)
      m

tactic: rfl
state_before: case H
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
m : Fin (n + 1) → E
⊢ ↑(↑(iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f s y) s x) (init m)) (m (last n)) =
    ↑((↑(continuousMultilinearCurryRightEquiv' 𝕜 n E F) ∘ iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f s y) s) x)
      m
Theorem: Submodule.mapQ_comp
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: ext
state_before: R : Type u_5
M : Type u_6
r : R
x y : M
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝⁶ : Ring R₂
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
R₃ : Type u_1
M₃ : Type u_2
inst✝³ : Ring R₃
inst✝² : AddCommGroup M₃
inst✝¹ : Module R₃ M₃
p₂ : Submodule R₂ M₂
p₃ : Submodule R₃ M₃
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
hf : p ≤ comap f p₂
hg : p₂ ≤ comap g p₃
h : optParam (p ≤ comap f (comap g p₃)) (_ : p ≤ comap f (comap g p₃))
⊢ mapQ p p₃ (comp g f) h = comp (mapQ p₂ p₃ g hg) (mapQ p p₂ f hf)

tactic: simp
state_before: case h.h
R : Type u_5
M : Type u_6
r : R
x y : M
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝⁶ : Ring R₂
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
R₃ : Type u_1
M₃ : Type u_2
inst✝³ : Ring R₃
inst✝² : AddCommGroup M₃
inst✝¹ : Module R₃ M₃
p₂ : Submodule R₂ M₂
p₃ : Submodule R₃ M₃
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
hf : p ≤ comap f p₂
hg : p₂ ≤ comap g p₃
h : optParam (p ≤ comap f (comap g p₃)) (_ : p ≤ comap f (comap g p₃))
x✝ : M
⊢ ↑(comp (mapQ p p₃ (comp g f) h) (mkQ p)) x✝ = ↑(comp (comp (mapQ p₂ p₃ g hg) (mapQ p p₂ f hf)) (mkQ p)) x✝
Theorem: PadicInt.norm_le_pow_iff_norm_lt_pow_add_one
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [norm_def]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℤ
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)

tactic: exact Padic.norm_le_pow_iff_norm_lt_pow_add_one _ _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℤ
⊢ ‖↑x‖ ≤ ↑p ^ n ↔ ‖↑x‖ < ↑p ^ (n + 1)
Theorem: MeasureTheory.weightedSMul_congr
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext1 x
state_before: α : Type u_1
E : Type ?u.42851
F : Type u_2
𝕜 : Type ?u.42857
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : ↑↑μ s = ↑↑μ t
⊢ weightedSMul μ s = weightedSMul μ t

tactic: simp_rw [weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type ?u.42851
F : Type u_2
𝕜 : Type ?u.42857
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : ↑↑μ s = ↑↑μ t
x : F
⊢ ↑(weightedSMul μ s) x = ↑(weightedSMul μ t) x

tactic: congr 2
state_before: case h
α : Type u_1
E : Type ?u.42851
F : Type u_2
𝕜 : Type ?u.42857
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
s t : Set α
hst : ↑↑μ s = ↑↑μ t
x : F
⊢ ENNReal.toReal (↑↑μ s) • x = ENNReal.toReal (↑↑μ t) • x
Theorem: MeasureTheory.map_div_right_eq_self
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: simp_rw [div_eq_mul_inv, map_mul_right_eq_self μ g⁻¹]
state_before: 𝕜 : Type ?u.311574
G : Type u_1
H : Type ?u.311580
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : DivInvMonoid G
μ : Measure G
inst✝ : IsMulRightInvariant μ
g : G
⊢ Measure.map (fun x => x / g) μ = μ