tasksource/leandojo huggingface dataset:
Theorem: Filter.map_prod_map_const_id_principal_coprod_principal
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [principal_coprod_principal, map_principal]
state_before: α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
⊢ map (Prod.map (fun x => b) id) (Filter.coprod (𝓟 {a}) (𝓟 {i})) = 𝓟 ({b} ×ˢ univ)

tactic: congr
state_before: α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
⊢ 𝓟 (Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ) = 𝓟 ({b} ×ˢ univ)

tactic: ext ⟨b', i'⟩
state_before: case e_s
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
⊢ Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ = {b} ×ˢ univ

tactic: constructor
state_before: case e_s.h.mk
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
b' : β
i' : ι
⊢ (b', i') ∈ Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ ↔ (b', i') ∈ {b} ×ˢ univ

tactic: rintro ⟨⟨a'', i''⟩, _, h₂, h₃⟩
state_before: case e_s.h.mk.mp
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
b' : β
i' : ι
⊢ (b', i') ∈ Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ → (b', i') ∈ {b} ×ˢ univ

tactic: simp
state_before: case e_s.h.mk.mp.intro.mk.intro.refl
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
a'' : α
i'' : ι
left✝ : (a'', i'') ∈ ({a}ᶜ ×ˢ {i}ᶜ)ᶜ
⊢ ((fun x => b) a'', id i'') ∈ {b} ×ˢ univ

tactic: rintro ⟨h₁, _⟩
state_before: case e_s.h.mk.mpr
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
b' : β
i' : ι
⊢ (b', i') ∈ {b} ×ˢ univ → (b', i') ∈ Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ

tactic: use (a, i')
state_before: case e_s.h.mk.mpr.intro
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
b' : β
i' : ι
h₁ : (b', i').fst ∈ {b}
right✝ : (b', i').snd ∈ univ
⊢ (b', i') ∈ Prod.map (fun x => b) id '' ({a}ᶜ ×ˢ {i}ᶜ)ᶜ

tactic: simpa using h₁.symm
state_before: case e_s.h.mk.mpr.intro
α✝ : Type ?u.66772
β✝ : Type ?u.66775
γ : Type ?u.66778
δ : Type ?u.66781
ι✝ : Sort ?u.66784
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
b' : β
i' : ι
h₁ : (b', i').fst ∈ {b}
right✝ : (b', i').snd ∈ univ
⊢ (a, i') ∈ ({a}ᶜ ×ˢ {i}ᶜ)ᶜ ∧ Prod.map (fun x => b) id (a, i') = (b', i')
Theorem: Finsupp.count_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: rw [toMultiset_apply]
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ Multiset.count a (↑toMultiset f) = sum f fun x n => Multiset.count a (n • {x})

tactic: exact map_sum (Multiset.countAddMonoidHom a) _ f.support
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ Multiset.count a (sum f fun a n => n • {a}) = sum f fun x n => Multiset.count a (n • {x})

tactic: simp only [Multiset.count_nsmul]
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ (sum f fun x n => Multiset.count a (n • {x})) = sum f fun x n => n * Multiset.count a {x}

tactic: simp only [Multiset.count_singleton, if_false, H.symm, mul_zero]
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a a' : α
x✝ : a' ∈ f.support
H : a' ≠ a
⊢ (fun x n => n * Multiset.count a {x}) a' (↑f a') = 0

tactic: simp only [not_mem_support_iff.1 H, zero_mul]
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
H : ¬a ∈ f.support
⊢ (fun x n => n * Multiset.count a {x}) a (↑f a) = 0

tactic: rw [Multiset.count_singleton_self, mul_one]
state_before: α : Type u_1
β : Type ?u.53685
ι : Type ?u.53688
inst✝ : DecidableEq α
f : α →₀ ℕ
a : α
⊢ ↑f a * Multiset.count a {a} = ↑f a
Theorem: Real.Angle.cos_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← cos_pi_div_two, ← cos_coe, cos_eq_iff_eq_or_eq_neg, ← coe_neg, ← neg_div]
state_before: θ : Angle
⊢ cos θ = 0 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
Theorem: Nat.gcd_gcd_self_left_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm, gcd_gcd_self_right_right]
state_before: m n : Nat
⊢ gcd (gcd n m) m = gcd n m
Theorem: List.get_reverse_aux₁
File: Mathlib/Data/List/Basic.lean

tactic: rw [show i + length (a :: l) = i + 1 + length l from add_right_comm i (length l) 1]
state_before: ι : Type ?u.93887
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l r : List α
i : ℕ
⊢ ∀ (h1 : i + length (a :: l) < length (reverseAux (a :: l) r)) (h2 : i < length r),
    get (reverseAux (a :: l) r) { val := i + length (a :: l), isLt := h1 } = get r { val := i, isLt := h2 }

tactic: exact fun h1 h2 => get_reverse_aux₁ l (a :: r) (i + 1) h1 (succ_lt_succ h2)
state_before: ι : Type ?u.93887
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l r : List α
i : ℕ
⊢ ∀ (h1 : i + 1 + length l < length (reverseAux (a :: l) r)) (h2 : i < length r),
    get (reverseAux (a :: l) r) { val := i + 1 + length l, isLt := h1 } = get r { val := i, isLt := h2 }
Theorem: CategoryTheory.NonPreadditiveAbelian.comp_sub
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [sub_def, ← Category.assoc, prod.comp_lift, sub_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ f ≫ (g - h) = f ≫ g - f ≫ h
Theorem: Set.op_mem_op
File: Mathlib/Data/Set/Opposite.lean

tactic: rfl
state_before: α : Type u_1
s : Set α
a : α
⊢ op a ∈ Set.op s ↔ a ∈ s
Theorem: MeasureTheory.snorm_smul_measure_of_ne_zero_of_ne_top
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [snorm_eq_snorm' hp_ne_zero hp_ne_top]
state_before: α : Type u_1
E : Type ?u.2068541
F : Type u_2
G : Type ?u.2068547
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ snorm f p (c • μ) = c ^ ENNReal.toReal (1 / p) • snorm f p μ

tactic: rw [snorm'_smul_measure ENNReal.toReal_nonneg]
state_before: α : Type u_1
E : Type ?u.2068541
F : Type u_2
G : Type ?u.2068547
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ snorm' f (ENNReal.toReal p) (c • μ) = c ^ ENNReal.toReal (1 / p) • snorm' f (ENNReal.toReal p) μ

tactic: congr
state_before: α : Type u_1
E : Type ?u.2068541
F : Type u_2
G : Type ?u.2068547
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ c ^ (1 / ENNReal.toReal p) * snorm' f (ENNReal.toReal p) μ =
    c ^ ENNReal.toReal (1 / p) • snorm' f (ENNReal.toReal p) μ

tactic: simp_rw [one_div]
state_before: case e_a.e_a
α : Type u_1
E : Type ?u.2068541
F : Type u_2
G : Type ?u.2068547
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ 1 / ENNReal.toReal p = ENNReal.toReal (1 / p)

tactic: rw [ENNReal.toReal_inv]
state_before: case e_a.e_a
α : Type u_1
E : Type ?u.2068541
F : Type u_2
G : Type ?u.2068547
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
c : ℝ≥0∞
⊢ (ENNReal.toReal p)⁻¹ = ENNReal.toReal p⁻¹
Theorem: toIcoMod_zero_sub_comm
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [← neg_sub, toIcoMod_neg, neg_zero]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp 0 (a - b) = p - toIocMod hp 0 (b - a)
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_zero
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [sub_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a - 0 = a

tactic: conv_lhs =>
  congr; congr; rw [← Category.comp_id a]
  case a.g => rw [show 0 = a ≫ (0 : Y ⟶ Y) by simp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ prod.lift a 0 ≫ σ = a

tactic: rw [← prod.comp_lift, Category.assoc, lift_σ, Category.comp_id]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ prod.lift (a ≫ 𝟙 Y) (a ≫ 0) ≫ σ = a

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ 0 = a ≫ 0
Theorem: Polynomial.X_pow_mul
File: Mathlib/Data/Polynomial/Basic.lean

tactic: induction' n with n ih
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ X ^ n * p = p * X ^ n

tactic: simp
state_before: case zero
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ X ^ Nat.zero * p = p * X ^ Nat.zero

tactic: conv_lhs => rw [pow_succ']
state_before: case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
ih : X ^ n * p = p * X ^ n
⊢ X ^ Nat.succ n * p = p * X ^ Nat.succ n

tactic: rw [mul_assoc, X_mul, ← mul_assoc, ih, mul_assoc, ← pow_succ']
state_before: case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
ih : X ^ n * p = p * X ^ n
⊢ X ^ n * X * p = p * X ^ Nat.succ n
Theorem: Metric.exists_local_min_mem_ball
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp_rw [← closedBall_diff_ball] at hf1
state_before: α : Type u
β : Type v
X : Type ?u.542746
ι : Type ?u.542749
inst✝⁴ : PseudoMetricSpace α
inst✝³ : ProperSpace α
inst✝² : TopologicalSpace β
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a z : α
r : ℝ
hf : ContinuousOn f (closedBall a r)
hz : z ∈ closedBall a r
hf1 : ∀ (z' : α), z' ∈ sphere a r → f z < f z'
⊢ ∃ z, z ∈ ball a r ∧ IsLocalMin f z

tactic: exact (isCompact_closedBall a r).exists_local_min_mem_open ball_subset_closedBall hf hz hf1
  isOpen_ball
state_before: α : Type u
β : Type v
X : Type ?u.542746
ι : Type ?u.542749
inst✝⁴ : PseudoMetricSpace α
inst✝³ : ProperSpace α
inst✝² : TopologicalSpace β
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a z : α
r : ℝ
hf : ContinuousOn f (closedBall a r)
hz : z ∈ closedBall a r
hf1 : ∀ (z' : α), z' ∈ closedBall a r \ ball a r → f z < f z'
⊢ ∃ z, z ∈ ball a r ∧ IsLocalMin f z
Theorem: LinearMap.ker_prodMap
File: Mathlib/LinearAlgebra/Prod.lean

tactic: dsimp only [ker]
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.119528
M₆ : Type ?u.119531
S : Type ?u.119534
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
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₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ ker (prodMap f g) = Submodule.prod (ker f) (ker g)

tactic: rw [← prodMap_comap_prod, Submodule.prod_bot]
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.119528
M₆ : Type ?u.119531
S : Type ?u.119534
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
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₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ Submodule.comap (prodMap f g) ⊥ = Submodule.prod (Submodule.comap f ⊥) (Submodule.comap g ⊥)
Theorem: LieModule.isNilpotent_iff_exists_ucs_eq_top
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: rw [LieModule.isNilpotent_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ LieModule.IsNilpotent R L M ↔ ∃ k, ucs k ⊥ = ⊤

tactic: exact exists_congr fun k => by simp [ucs_eq_top_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ (∃ k, LieModule.lowerCentralSeries R L M k = ⊥) ↔ ∃ k, ucs k ⊥ = ⊤

tactic: simp [ucs_eq_top_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ LieModule.lowerCentralSeries R L M k = ⊥ ↔ ucs k ⊥ = ⊤
Theorem: Computation.parallel_empty
File: Mathlib/Data/Seq/Parallel.lean

tactic: let ⟨c, cs, _⟩ := exists_of_mem_parallel m
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : WSeq.head S ~> none
x✝ : Terminates (parallel S)
a : α
m : a ∈ parallel S
⊢ False

tactic: let ⟨n, nm⟩ := WSeq.exists_get?_of_mem cs
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : WSeq.head S ~> none
x✝ : Terminates (parallel S)
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
⊢ False

tactic: let ⟨c', h'⟩ := WSeq.head_some_of_get?_some nm
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : WSeq.head S ~> none
x✝ : Terminates (parallel S)
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ WSeq.get? S n
⊢ False

tactic: injection h h'
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : WSeq.head S ~> none
x✝ : Terminates (parallel S)
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ WSeq.get? S n
c' : Computation α
h' : some c' ∈ WSeq.head S
⊢ False
Theorem: PartENat.toWithTop_natCast
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp only [← toWithTop_some]
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ toWithTop ↑n = ↑n

tactic: congr
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ toWithTop ↑n = toWithTop ↑n
Theorem: IsLprojection.distrib_lattice_lemma
File: Mathlib/Analysis/NormedSpace/MStructure.lean

tactic: rw [add_mul, mul_add, mul_add, (mul_assoc _ (R : M) (↑Q * ↑R * ↑(Pᶜ))),
  ← mul_assoc (R : M) (↑Q * ↑R) _, ← coe_inf Q, (Pᶜ.prop.commute R.prop).eq,
  ((Q ⊓ R).prop.commute (Pᶜ).prop).eq, (R.prop.commute (Q ⊓ R).prop).eq, coe_inf Q,
  mul_assoc (Q : M), ←mul_assoc, mul_assoc (R : M), (Pᶜ.prop.commute P.prop).eq, mul_compl_self,
  MulZeroClass.zero_mul, MulZeroClass.mul_zero, zero_add, add_zero, ← mul_assoc, P.prop.proj.eq,
  R.prop.proj.eq, ←coe_inf Q, mul_assoc, ((Q ⊓ R).prop.commute (Pᶜ).prop).eq, ← mul_assoc,
  Pᶜ.prop.proj.eq]
state_before: X : Type u_2
inst✝³ : NormedAddCommGroup X
M : Type u_1
inst✝² : Ring M
inst✝¹ : Module M X
inst✝ : FaithfulSMul M X
P Q R : { P // IsLprojection X P }
⊢ (↑P + ↑(Pᶜ) * ↑R) * (↑P + ↑Q * ↑R * ↑(Pᶜ)) = ↑P + ↑Q * ↑R * ↑(Pᶜ)
Theorem: MeasureTheory.Measure.map_linearMap_add_haar_pi_eq_smul_add_haar
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : IsAddHaarMeasure μ
⊢ map (↑f) μ = ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) • μ

tactic: have := addHaarMeasure_unique μ (piIcc01 ι)
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : IsAddHaarMeasure μ
val✝ : Fintype ι
⊢ map (↑f) μ = ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) • μ

tactic: rw [this, addHaarMeasure_eq_volume_pi, Measure.map_smul,
  Real.map_linearMap_volume_pi_eq_smul_volume_pi hf, smul_comm]
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : IsAddHaarMeasure μ
val✝ : Fintype ι
this : μ = ↑↑μ ↑(piIcc01 ι) • addHaarMeasure (piIcc01 ι)
⊢ map (↑f) μ = ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) • μ
Theorem: vsub_add_vsub_cancel
File: Mathlib/Algebra/AddTorsor.lean

tactic: apply vadd_right_cancel p3
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p1 p2 p3 : P
⊢ p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3

tactic: rw [add_vadd, vsub_vadd, vsub_vadd, vsub_vadd]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p1 p2 p3 : P
⊢ p1 -ᵥ p2 + (p2 -ᵥ p3) +ᵥ p3 = p1 -ᵥ p3 +ᵥ p3
Theorem: MeasureTheory.Measure.restrict_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [*, hf ht]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.305334
δ : Type ?u.305337
ι : Type ?u.305340
R : Type ?u.305343
R' : Type ?u.305346
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
t : Set β
ht : MeasurableSet t
⊢ ↑↑(restrict (map f μ) s) t = ↑↑(map f (restrict μ (f ⁻¹' s))) t
Theorem: Metric.tendsto_atTop'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [true_and, gt_iff_lt, mem_Ioi, mem_ball]
state_before: α : Type u
β : Type v
X : Type ?u.142783
ι : Type ?u.142786
inst✝³ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝² : Nonempty β
inst✝¹ : SemilatticeSup β
inst✝ : NoMaxOrder β
u : β → α
a : α
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, True ∧ ∀ (x : β), x ∈ Ioi ia → u x ∈ ball a ib) ↔
    ∀ (ε : ℝ), ε > 0 → ∃ N, ∀ (n : β), n > N → dist (u n) a < ε
Theorem: NormedSpace.dualPairing_separatingLeft
File: Mathlib/Analysis/NormedSpace/Dual.lean

tactic: rw [LinearMap.separatingLeft_iff_ker_eq_bot, LinearMap.ker_eq_bot]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type ?u.39284
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ LinearMap.SeparatingLeft (dualPairing 𝕜 E)

tactic: exact ContinuousLinearMap.coe_injective
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type ?u.39284
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
⊢ Function.Injective ↑(dualPairing 𝕜 E)
Theorem: Set.Ioc_top
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
β : Type ?u.54485
inst✝¹ : Preorder α
inst✝ : OrderTop α
a : α
⊢ Ioc a ⊤ = Ioi a
Theorem: QuaternionAlgebra.mul_coe_eq_smul
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [← coe_commutes, coe_mul_eq_smul]
state_before: S : Type ?u.265744
T : Type ?u.265747
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a * ↑r = r • a
Theorem: ProbabilityMeasure.toFiniteMeasure_normalize_eq_self
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: apply ProbabilityMeasure.eq_of_forall_apply_eq
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0✝ : MeasurableSpace Ω
μ✝ : FiniteMeasure Ω
m0 : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ normalize (ProbabilityMeasure.toFiniteMeasure μ) = μ

tactic: intro s _s_mble
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0✝ : MeasurableSpace Ω
μ✝ : FiniteMeasure Ω
m0 : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ ∀ (s : Set Ω),
    MeasurableSet s →
      (fun s => ENNReal.toNNReal (↑↑↑(normalize (ProbabilityMeasure.toFiniteMeasure μ)) s)) s =
        (fun s => ENNReal.toNNReal (↑↑↑μ s)) s

tactic: rw [μ.toFiniteMeasure.normalize_eq_of_nonzero μ.toFiniteMeasure_nonzero s]
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0✝ : MeasurableSpace Ω
μ✝ : FiniteMeasure Ω
m0 : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s : Set Ω
_s_mble : MeasurableSet s
⊢ (fun s => ENNReal.toNNReal (↑↑↑(normalize (ProbabilityMeasure.toFiniteMeasure μ)) s)) s =
    (fun s => ENNReal.toNNReal (↑↑↑μ s)) s

tactic: simp only [ProbabilityMeasure.mass_toFiniteMeasure, inv_one, one_mul]
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0✝ : MeasurableSpace Ω
μ✝ : FiniteMeasure Ω
m0 : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s : Set Ω
_s_mble : MeasurableSet s
⊢ (mass (ProbabilityMeasure.toFiniteMeasure μ))⁻¹ *
      (fun s => ENNReal.toNNReal (↑↑↑(ProbabilityMeasure.toFiniteMeasure μ) s)) s =
    (fun s => ENNReal.toNNReal (↑↑↑μ s)) s

tactic: congr
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0✝ : MeasurableSpace Ω
μ✝ : FiniteMeasure Ω
m0 : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s : Set Ω
_s_mble : MeasurableSet s
⊢ ENNReal.toNNReal (↑↑↑(ProbabilityMeasure.toFiniteMeasure μ) s) = ENNReal.toNNReal (↑↑↑μ s)
Theorem: Isometry.diam_image
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [Metric.diam, Metric.diam, hf.ediam_image]
state_before: ι : Type ?u.60676
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
s : Set α
⊢ Metric.diam (f '' s) = Metric.diam s
Theorem: Nat.choose_succ_right_eq
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: have e : (n + 1) * choose n k = choose n k * (k + 1) + choose n (k + 1) * (k + 1)
state_before: n k : ℕ
⊢ choose n (k + 1) * (k + 1) = choose n k * (n - k)

tactic: rw [← right_distrib, ← choose_succ_succ, succ_mul_choose_eq]
state_before: case e
n k : ℕ
⊢ (n + 1) * choose n k = choose n k * (k + 1) + choose n (k + 1) * (k + 1)

n k : ℕ
e : (n + 1) * choose n k = choose n k * (k + 1) + choose n (k + 1) * (k + 1)
⊢ choose n (k + 1) * (k + 1) = choose n k * (n - k)

tactic: rw [← tsub_eq_of_eq_add_rev e, mul_comm, ← mul_tsub, add_tsub_add_eq_tsub_right]
state_before: n k : ℕ
e : (n + 1) * choose n k = choose n k * (k + 1) + choose n (k + 1) * (k + 1)
⊢ choose n (k + 1) * (k + 1) = choose n k * (n - k)
Theorem: CategoryTheory.Sheaf.Subcanonical.of_yoneda_isSheaf
File: Mathlib/CategoryTheory/Sites/Canonical.lean

tactic: rintro P ⟨X, rfl⟩
state_before: C : Type u
inst✝ : Category C
P : Cᵒᵖ ⥤ Type v
X Y : C
S : Sieve X
R : Presieve X
J✝ J₂ J : GrothendieckTopology C
h : ∀ (X : C), Presieve.IsSheaf J (yoneda.obj X)
⊢ ∀ (P : Cᵒᵖ ⥤ Type v), P ∈ Set.range yoneda.toPrefunctor.obj → Presieve.IsSheaf J P

tactic: apply h
state_before: case intro
C : Type u
inst✝ : Category C
P : Cᵒᵖ ⥤ Type v
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
J✝ J₂ J : GrothendieckTopology C
h : ∀ (X : C), Presieve.IsSheaf J (yoneda.obj X)
X : C
⊢ Presieve.IsSheaf J (yoneda.obj X)