tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.measurableSet_support
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [f.support_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.905162
δ : Type ?u.905165
m : MeasurableSpace α
inst✝² : Zero β
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β
inst✝ : MeasurableSpace α
f : α →ₛ β
⊢ MeasurableSet (support ↑f)

tactic: exact Finset.measurableSet_biUnion _ fun y _ => measurableSet_fiber _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.905162
δ : Type ?u.905165
m : MeasurableSpace α
inst✝² : Zero β
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β
inst✝ : MeasurableSpace α
f : α →ₛ β
⊢ MeasurableSet (⋃ (y : β) (_ : y ∈ filter (fun y => y ≠ 0) (SimpleFunc.range f)), ↑f ⁻¹' {y})
Theorem: Dfinsupp.filter_apply_neg
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [filter_apply, if_neg h]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
h : ¬p i
⊢ ↑(filter p f) i = 0
Theorem: continuousWithinAt_iff_continuousAt
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← univ_inter s, continuousWithinAt_inter h, continuousWithinAt_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.331376
δ : Type ?u.331379
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
h : s ∈ 𝓝 x
⊢ ContinuousWithinAt f s x ↔ ContinuousAt f x
Theorem: Basis.sum_dual_apply_smul_coord
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext m
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
⊢ ∑ x : ι, ↑f (↑b x) • coord b x = f

tactic: simp_rw [LinearMap.sum_apply, LinearMap.smul_apply, smul_eq_mul, mul_comm (f _), ← smul_eq_mul, ←
  f.map_smul, ← f.map_sum, Basis.coord_apply, Basis.sum_repr]
state_before: case h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
m : M
⊢ ↑(∑ x : ι, ↑f (↑b x) • coord b x) m = ↑f m
Theorem: CategoryTheory.IsIso.inv_hom_id_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp [← Category.assoc]
state_before: C : Type u
inst✝ : Category C
X Y Z✝ : C
f : X ⟶ Y
I : IsIso f
Z : C
g : Y ⟶ Z
⊢ inv f ≫ f ≫ g = g
Theorem: Cubic.degree_of_d_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_d_eq_zero ha hb hc hd, degree_zero]
state_before: R : Type u_1
S : Type ?u.585751
F : Type ?u.585754
K : Type ?u.585757
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 0
hd : P.d = 0
⊢ degree (toPoly P) = ⊥
Theorem: Multiset.count_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: split_ifs with h
state_before: α : Type u_1
β : Type ?u.397803
γ : Type ?u.397806
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
⊢ count a (filter p s) = if p a then count a s else 0

tactic: exact count_filter_of_pos h
state_before: case inl
α : Type u_1
β : Type ?u.397803
γ : Type ?u.397806
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
⊢ count a (filter p s) = count a s

tactic: exact count_filter_of_neg h
state_before: case inr
α : Type u_1
β : Type ?u.397803
γ : Type ?u.397806
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : ¬p a
⊢ count a (filter p s) = 0
Theorem: MeasureTheory.Measure.lt_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [le_iff, not_forall, not_le, exists_prop]
state_before: α : Type u_1
β : Type ?u.144465
γ : Type ?u.144468
δ : Type ?u.144471
ι : Type ?u.144474
R : Type ?u.144477
R' : Type ?u.144480
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ ¬ν ≤ μ ↔ ∃ s, MeasurableSet s ∧ ↑↑μ s < ↑↑ν s
Theorem: AffineSubspace.wOppSide_vadd_right_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [wOppSide_comm, wOppSide_vadd_left_iff hv, wOppSide_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.148575
P : Type u_3
P' : Type ?u.148581
inst✝⁶ : StrictOrderedCommRing 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
v : V
hv : v ∈ direction s
⊢ WOppSide s x (v +ᵥ y) ↔ WOppSide s x y
Theorem: List.cons_subset_cons
File: Std/Data/List/Lemmas.lean

tactic: simp only [mem_cons]
state_before: α : Type u_1
l₁ l₂ : List α
a : α
s : l₁ ⊆ l₂
x✝ : α
⊢ x✝ ∈ a :: l₁ → x✝ ∈ a :: l₂

tactic: exact Or.imp_right (@s _)
state_before: α : Type u_1
l₁ l₂ : List α
a : α
s : l₁ ⊆ l₂
x✝ : α
⊢ x✝ = a ∨ x✝ ∈ l₁ → x✝ = a ∨ x✝ ∈ l₂
Theorem: MeasureTheory.snorm'_mono_measure
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [snorm']
state_before: α : Type u_1
E : Type ?u.1836292
F : Type u_2
G : Type ?u.1836298
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hq : 0 ≤ q
⊢ snorm' f q ν ≤ snorm' f q μ

tactic: suffices h_integral_mono : (∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ q ∂ν) ≤ ∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ q ∂μ from
  ENNReal.rpow_le_rpow h_integral_mono (by simp [hq])
state_before: α : Type u_1
E : Type ?u.1836292
F : Type u_2
G : Type ?u.1836298
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hq : 0 ≤ q
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂ν) ^ (1 / q) ≤ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)

tactic: exact lintegral_mono' hμν le_rfl
state_before: α : Type u_1
E : Type ?u.1836292
F : Type u_2
G : Type ?u.1836298
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hq : 0 ≤ q
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂ν) ≤ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ

tactic: simp [hq]
state_before: α : Type u_1
E : Type ?u.1836292
F : Type u_2
G : Type ?u.1836298
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hq : 0 ≤ q
h_integral_mono : (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂ν) ≤ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ
⊢ 0 ≤ 1 / q
Theorem: abs_eq_abs
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: α : Type u_1
inst✝¹ : AddGroup α
inst✝ : LinearOrder α
a b : α
⊢ abs a = abs b ↔ a = b ∨ a = -b

tactic: obtain rfl | rfl := eq_or_eq_neg_of_abs_eq h <;>
  simpa only [neg_eq_iff_eq_neg (a := |b|), neg_inj, or_comm] using abs_choice b
state_before: case refine'_1
α : Type u_1
inst✝¹ : AddGroup α
inst✝ : LinearOrder α
a b : α
h : abs a = abs b
⊢ a = b ∨ a = -b

tactic: cases' h with h h <;>
simp [h, abs_neg]
state_before: case refine'_2
α : Type u_1
inst✝¹ : AddGroup α
inst✝ : LinearOrder α
a b : α
h : a = b ∨ a = -b
⊢ abs a = abs b
Theorem: Subring.mem_iSup_of_directed
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ (x ∈ ⨆ (i : ι), S i) ↔ ∃ i, x ∈ S i

tactic: let U : Subring R :=
  Subring.mk' (⋃ i, (S i : Set R)) (⨆ i, (S i).toSubmonoid) (⨆ i, (S i).toAddSubgroup)
    (Submonoid.coe_iSup_of_directed <| hS.mono_comp _ fun _ _ => id)
    (AddSubgroup.coe_iSup_of_directed <| hS.mono_comp _ fun _ _ => id)
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ (x ∈ ⨆ (i : ι), S i) → ∃ i, x ∈ S i

tactic: suffices (⨆ i, S i) ≤ U by intro h; simpa using (this h)
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
U : Subring R :=
  Subring.mk' (⋃ (i : ι), ↑(S i)) (⨆ (i : ι), (S i).toSubmonoid) (⨆ (i : ι), toAddSubgroup (S i))
    (_ : ↑(⨆ (i : ι), (S i).toSubmonoid) = ⋃ (i : ι), ↑(S i).toSubmonoid)
    (_ : ↑(⨆ (i : ι), toAddSubgroup (S i)) = ⋃ (i : ι), ↑(toAddSubgroup (S i)))
⊢ (x ∈ ⨆ (i : ι), S i) → ∃ i, x ∈ S i

tactic: exact iSup_le fun i x hx => Set.mem_iUnion.2 ⟨i, hx⟩
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
U : Subring R :=
  Subring.mk' (⋃ (i : ι), ↑(S i)) (⨆ (i : ι), (S i).toSubmonoid) (⨆ (i : ι), toAddSubgroup (S i))
    (_ : ↑(⨆ (i : ι), (S i).toSubmonoid) = ⋃ (i : ι), ↑(S i).toSubmonoid)
    (_ : ↑(⨆ (i : ι), toAddSubgroup (S i)) = ⋃ (i : ι), ↑(toAddSubgroup (S i)))
⊢ (⨆ (i : ι), S i) ≤ U

tactic: intro h
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
U : Subring R :=
  Subring.mk' (⋃ (i : ι), ↑(S i)) (⨆ (i : ι), (S i).toSubmonoid) (⨆ (i : ι), toAddSubgroup (S i))
    (_ : ↑(⨆ (i : ι), (S i).toSubmonoid) = ⋃ (i : ι), ↑(S i).toSubmonoid)
    (_ : ↑(⨆ (i : ι), toAddSubgroup (S i)) = ⋃ (i : ι), ↑(toAddSubgroup (S i)))
this : (⨆ (i : ι), S i) ≤ U
⊢ (x ∈ ⨆ (i : ι), S i) → ∃ i, x ∈ S i

tactic: simpa using (this h)
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
U : Subring R :=
  Subring.mk' (⋃ (i : ι), ↑(S i)) (⨆ (i : ι), (S i).toSubmonoid) (⨆ (i : ι), toAddSubgroup (S i))
    (_ : ↑(⨆ (i : ι), (S i).toSubmonoid) = ⋃ (i : ι), ↑(S i).toSubmonoid)
    (_ : ↑(⨆ (i : ι), toAddSubgroup (S i)) = ⋃ (i : ι), ↑(toAddSubgroup (S i)))
this : (⨆ (i : ι), S i) ≤ U
h : x ∈ ⨆ (i : ι), S i
⊢ ∃ i, x ∈ S i
Theorem: midpoint_self_neg
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_eq_smul_add, add_neg_self, smul_zero]
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.131151
P : Type ?u.131154
P' : Type ?u.131157
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y z : P
x : V
⊢ midpoint R x (-x) = 0
Theorem: List.permutationsAux2_snd_eq
File: Mathlib/Data/List/Permutation.lean

tactic: rw [← permutationsAux2_append, map_permutationsAux2, permutationsAux2_comp_append]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts r ys f).snd = map (fun x => f (x ++ ts)) (permutationsAux2 t [] [] ys id).snd ++ r
Theorem: MeasureTheory.Integrable.withDensityᵥ_trim_eq_integral
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: rw [VectorMeasure.trim_measurableSet_eq hm hi, withDensityᵥ_apply hf (hm _ hi)]
state_before: α : Type u_1
β : Type ?u.163840
m✝ : MeasurableSpace α
μ✝ ν : Measure α
E : Type ?u.163859
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g : α → E
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ
hf : Integrable f
i : Set α
hi : MeasurableSet i
⊢ ↑(VectorMeasure.trim (withDensityᵥ μ f) hm) i = ∫ (x : α) in i, f x ∂μ
Theorem: MeasurableSet.const
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: by_cases p <;> simp [*]
state_before: α : Type u_1
β : Type ?u.10509
γ : Type ?u.10512
δ : Type ?u.10515
δ' : Type ?u.10518
ι : Sort ?u.10521
s t u : Set α
m : MeasurableSpace α
p : Prop
⊢ MeasurableSet {_a | p}
Theorem: List.modifyNthTR_go_eq
File: Std/Data/List/Basic.lean

tactic: cases n <;> simp [modifyNthTR.go, modifyNth]
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
n : Nat
⊢ modifyNthTR.go f [] n acc = acc.data ++ modifyNth f n []

tactic: simp [modifyNthTR.go, modifyNth]
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
a : α✝
l : List α✝
⊢ modifyNthTR.go f (a :: l) 0 acc = acc.data ++ modifyNth f 0 (a :: l)

tactic: simp [modifyNthTR.go, modifyNth, modifyNthTR_go_eq l]
state_before: α✝ : Type u_1
f : α✝ → α✝
acc : Array α✝
a : α✝
l : List α✝
n : Nat
⊢ modifyNthTR.go f (a :: l) (n + 1) acc = acc.data ++ modifyNth f (n + 1) (a :: l)
Theorem: Order.not_isSuccLimit_of_noMax
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp
state_before: α : Type u_1
inst✝⁴ : Preorder α
a : α
inst✝³ : SuccOrder α
inst✝² : IsSuccArchimedean α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
⊢ ¬IsSuccLimit a
Theorem: Fin.card_Ico
File: Mathlib/Data/Fin/Interval.lean

tactic: rw [← Nat.card_Ico, ← map_valEmbedding_Ico, card_map]
state_before: n : ℕ
a b : Fin n
⊢ card (Ico a b) = ↑b - ↑a
Theorem: PowerSeries.coeff_zero_eq_constantCoeff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff, Finsupp.single_zero]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ ↑(coeff R 0) = ↑(constantCoeff R)

tactic: rfl
state_before: R : Type u_1
inst✝ : Semiring R
⊢ ↑(MvPowerSeries.coeff R 0) = ↑(constantCoeff R)
Theorem: Subtype.range_coe
File: Mathlib/Data/Set/Image.lean

tactic: rw [← Set.image_univ]
state_before: α : Type u_1
s : Set α
⊢ range val = s

tactic: simp [-Set.image_univ, coe_image]
state_before: α : Type u_1
s : Set α
⊢ val '' univ = s
Theorem: IsClosed.hausdorffDist_zero_iff_eq
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [← hausdorffEdist_zero_iff_eq_of_closed hs ht, hausdorffDist, ENNReal.toReal_eq_zero_iff,
  fin]
state_before: ι : Sort ?u.88218
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : IsClosed s
ht : IsClosed t
fin : hausdorffEdist s t ≠ ⊤
⊢ hausdorffDist s t = 0 ↔ s = t
Theorem: MeasureTheory.Measure.count_apply_finite'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [←
  @count_apply_finset' _ _ s_fin.toFinset (by simpa only [Finite.coe_toFinset] using s_mble)]
state_before: α : Type u_1
β : Type ?u.373338
γ : Type ?u.373341
δ : Type ?u.373344
ι : Type ?u.373347
R : Type ?u.373350
R' : Type ?u.373353
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
s : Set α
s_fin : Set.Finite s
s_mble : MeasurableSet s
⊢ ↑↑count s = ↑(Finset.card (Finite.toFinset s_fin))

tactic: simpa only [Finite.coe_toFinset] using s_mble
state_before: α : Type u_1
β : Type ?u.373338
γ : Type ?u.373341
δ : Type ?u.373344
ι : Type ?u.373347
R : Type ?u.373350
R' : Type ?u.373353
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
s : Set α
s_fin : Set.Finite s
s_mble : MeasurableSet s
⊢ MeasurableSet ↑(Finite.toFinset s_fin)
Theorem: Nat.fib_pos
File: Mathlib/Data/Nat/Fib.lean

tactic: decide
state_before: n : ℕ
n_pos : 0 < n
⊢ 0 < fib 1
Theorem: iSup_singleton
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.138634
γ : Type ?u.138637
ι : Sort ?u.138640
ι' : Sort ?u.138643
κ : ι → Sort ?u.138648
κ' : ι' → Sort ?u.138653
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b✝ : α
f : β → α
b : β
⊢ (⨆ (x : β) (_ : x ∈ {b}), f x) = f b
Theorem: CategoryTheory.Limits.prod.triangle
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: dsimp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y : C
⊢ (associator X (⊤_ C) Y).hom ≫ map (𝟙 X) (leftUnitor Y).hom = map (rightUnitor X).hom (𝟙 Y)

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y : C
⊢ lift (fst ≫ fst) (lift (fst ≫ snd) snd) ≫ map (𝟙 X) snd = map fst (𝟙 Y)

tactic: simp
state_before: case h₁
C : Type u
inst✝² : Category C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y : C
⊢ (lift (fst ≫ fst) (lift (fst ≫ snd) snd) ≫ map (𝟙 X) snd) ≫ fst = map fst (𝟙 Y) ≫ fst

case h₂
C : Type u
inst✝² : Category C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y : C
⊢ (lift (fst ≫ fst) (lift (fst ≫ snd) snd) ≫ map (𝟙 X) snd) ≫ snd = map fst (𝟙 Y) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝² : Category C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y : C
⊢ (lift (fst ≫ fst) (lift (fst ≫ snd) snd) ≫ map (𝟙 X) snd) ≫ snd = map fst (𝟙 Y) ≫ snd
Theorem: Continuous.connectedComponentsLift_continuous
File: Mathlib/Topology/Connected.lean

tactic: convert h.image_eq_of_connectedComponent_eq
state_before: α : Type u
β : Type v
ι : Type ?u.140029
π : ι → Type ?u.140034
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
inst✝ : TotallyDisconnectedSpace β
f : α → β
h : Continuous f
⊢ ∀ (a b : α), Setoid.r a b → f a = f b
Theorem: Function.Commute.minimalPeriod_of_comp_eq_mul_of_coprime
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply h.minimalPeriod_of_comp_dvd_mul.antisymm
state_before: α : Type u_1
β : Type ?u.27755
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ minimalPeriod (f ∘ g) x = minimalPeriod f x * minimalPeriod g x

tactic: suffices :
  ∀ {f g : α → α},
    Commute f g →
      coprime (minimalPeriod f x) (minimalPeriod g x) →
        minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
state_before: α : Type u_1
β : Type ?u.27755
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ minimalPeriod f x * minimalPeriod g x ∣ minimalPeriod (f ∘ g) x

tactic: intro f g h hco
state_before: case this
α : Type u_1
β : Type ?u.27755
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ ∀ {f g : α → α},
    Commute f g → coprime (minimalPeriod f x) (minimalPeriod g x) → minimalPeriod f x ∣ minimalPeriod (f ∘ g) x

tactic: refine' hco.dvd_of_dvd_mul_left (IsPeriodicPt.left_of_comp h _ _).minimalPeriod_dvd
state_before: case this
α : Type u_1
β : Type ?u.27755
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Commute f✝ g✝
hco✝ : coprime (minimalPeriod f✝ x) (minimalPeriod g✝ x)
f g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ minimalPeriod f x ∣ minimalPeriod (f ∘ g) x

tactic: exact hco.mul_dvd_of_dvd_of_dvd (this h hco) (h.comp_eq.symm ▸ this h.symm hco.symm)
state_before: α : Type u_1
β : Type ?u.27755
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
this :
  ∀ {f g : α → α},
    Commute f g → coprime (minimalPeriod f x) (minimalPeriod g x) → minimalPeriod f x ∣ minimalPeriod (f ∘ g) x
⊢ minimalPeriod f x * minimalPeriod g x ∣ minimalPeriod (f ∘ g) x

tactic: exact (isPeriodicPt_minimalPeriod _ _).const_mul _
state_before: case this.refine'_1
α : Type u_1
β : Type ?u.27755
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Commute f✝ g✝
hco✝ : coprime (minimalPeriod f✝ x) (minimalPeriod g✝ x)
f g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ IsPeriodicPt (f ∘ g) (minimalPeriod g x * minimalPeriod (f ∘ g) x) x

tactic: exact (isPeriodicPt_minimalPeriod _ _).mul_const _
state_before: case this.refine'_2
α : Type u_1
β : Type ?u.27755
f✝ fa : α → α
fb : β → β
x y : α
m n : ℕ
g✝ : α → α
h✝ : Commute f✝ g✝
hco✝ : coprime (minimalPeriod f✝ x) (minimalPeriod g✝ x)
f g : α → α
h : Commute f g
hco : coprime (minimalPeriod f x) (minimalPeriod g x)
⊢ IsPeriodicPt g (minimalPeriod g x * minimalPeriod (f ∘ g) x) x
Theorem: LinearMap.range_neg
File: Mathlib/LinearAlgebra/Basic.lean

tactic: change range ((-LinearMap.id : M₂ →ₗ[R₂] M₂).comp f) = _
state_before: R✝ : Type ?u.1110533
R₁ : Type ?u.1110536
R₂✝ : Type ?u.1110539
R₃ : Type ?u.1110542
R₄ : Type ?u.1110545
S : Type ?u.1110548
K : Type ?u.1110551
K₂ : Type ?u.1110554
M✝ : Type ?u.1110557
M' : Type ?u.1110560
M₁ : Type ?u.1110563
M₂✝ : Type ?u.1110566
M₃ : Type ?u.1110569
M₄ : Type ?u.1110572
N : Type ?u.1110575
N₂ : Type ?u.1110578
ι : Type ?u.1110581
V : Type ?u.1110584
V₂ : Type ?u.1110587
inst✝¹⁷ : Semiring R✝
inst✝¹⁶ : Semiring R₂✝
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : AddCommMonoid M✝
inst✝¹³ : AddCommMonoid M₂✝
inst✝¹² : AddCommMonoid M₃
σ₁₂ : R✝ →+* R₂✝
σ₂₃ : R₂✝ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝¹¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁰ : Module R✝ M✝
inst✝⁹ : Module R₂✝ M₂✝
inst✝⁸ : Module R₃ M₃
σ₂₁ : R₂✝ →+* R✝
τ₁₂✝ : R✝ →+* R₂✝
τ₂₃ : R₂✝ →+* R₃
τ₁₃ : R✝ →+* R₃
inst✝⁷ : RingHomCompTriple τ₁₂✝ τ₂₃ τ₁₃
F : Type ?u.1110997
sc : SemilinearMapClass F τ₁₂✝ M✝ M₂✝
R : Type u_1
R₂ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁶ : Semiring R
inst✝⁵ : Ring R₂
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
⊢ range (-f) = range f

tactic: rw [range_comp, Submodule.map_neg, Submodule.map_id]
state_before: R✝ : Type ?u.1110533
R₁ : Type ?u.1110536
R₂✝ : Type ?u.1110539
R₃ : Type ?u.1110542
R₄ : Type ?u.1110545
S : Type ?u.1110548
K : Type ?u.1110551
K₂ : Type ?u.1110554
M✝ : Type ?u.1110557
M' : Type ?u.1110560
M₁ : Type ?u.1110563
M₂✝ : Type ?u.1110566
M₃ : Type ?u.1110569
M₄ : Type ?u.1110572
N : Type ?u.1110575
N₂ : Type ?u.1110578
ι : Type ?u.1110581
V : Type ?u.1110584
V₂ : Type ?u.1110587
inst✝¹⁷ : Semiring R✝
inst✝¹⁶ : Semiring R₂✝
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : AddCommMonoid M✝
inst✝¹³ : AddCommMonoid M₂✝
inst✝¹² : AddCommMonoid M₃
σ₁₂ : R✝ →+* R₂✝
σ₂₃ : R₂✝ →+* R₃
σ₁₃ : R✝ →+* R₃
inst✝¹¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁰ : Module R✝ M✝
inst✝⁹ : Module R₂✝ M₂✝
inst✝⁸ : Module R₃ M₃
σ₂₁ : R₂✝ →+* R✝
τ₁₂✝ : R✝ →+* R₂✝
τ₂₃ : R₂✝ →+* R₃
τ₁₃ : R✝ →+* R₃
inst✝⁷ : RingHomCompTriple τ₁₂✝ τ₂₃ τ₁₃
F : Type ?u.1110997
sc : SemilinearMapClass F τ₁₂✝ M✝ M₂✝
R : Type u_1
R₂ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁶ : Semiring R
inst✝⁵ : Ring R₂
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
⊢ range (comp (-id) f) = range f