tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_idempotents_have_kernels
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: rw [isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
⊢ IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p

tactic: constructor
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p

tactic: intro h X p hp
state_before: case mp
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) → ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p

tactic: haveI : HasEqualizer (𝟙 X) (𝟙 X - p) := h X (𝟙 _ - p) (idem_of_id_sub_idem p hp)
state_before: case mp
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
h : ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ HasKernel p

tactic: convert hasKernel_of_hasEqualizer (𝟙 X) (𝟙 X - p)
state_before: case mp
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
h : ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
X : C
p : X ⟶ X
hp : p ≫ p = p
this : HasEqualizer (𝟙 X) (𝟙 X - p)
⊢ HasKernel p

tactic: rw [sub_sub_cancel]
state_before: case h.e'_6
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
h : ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
X : C
p : X ⟶ X
hp : p ≫ p = p
this : HasEqualizer (𝟙 X) (𝟙 X - p)
⊢ p = 𝟙 X - (𝟙 X - p)

tactic: intro h X p hp
state_before: case mpr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p) → ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p

tactic: haveI : HasKernel (𝟙 _ - p) := h X (𝟙 _ - p) (idem_of_id_sub_idem p hp)
state_before: case mpr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
h : ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ HasEqualizer (𝟙 X) p

tactic: apply Preadditive.hasEqualizer_of_hasKernel
state_before: case mpr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
h : ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
X : C
p : X ⟶ X
hp : p ≫ p = p
this : HasKernel (𝟙 X - p)
⊢ HasEqualizer (𝟙 X) p
Theorem: PowerSeries.coeff_zero_eq_constantCoeff_apply
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_zero_eq_constantCoeff]
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ ↑(coeff R 0) φ = ↑(constantCoeff R) φ
Theorem: Primrec.bind_decode_iff
File: Mathlib/Computability/Primrec.lean

tactic: simpa [encodek] using h.comp fst ((@Primrec.encode β _).comp snd)
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.116843
δ : Type ?u.116846
σ : Type u_1
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → Option σ
h : Primrec₂ fun a n => Option.bind (decode n) (f a)
⊢ Primrec₂ f
Theorem: Nat.min_le_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.min_def]
state_before: a b : Nat
⊢ min a b ≤ b

tactic: split <;> simp [*]
state_before: a b : Nat
⊢ (if a ≤ b then a else b) ≤ b
Theorem: HasStrictDerivAt.mul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: convert hc.mul (hasStrictDerivAt_const x d) using 1
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.254693
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
d : 𝔸
⊢ HasStrictDerivAt (fun y => c y * d) (c' * d) x

tactic: rw [mul_zero, add_zero]
state_before: case h.e'_7
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.254693
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
d : 𝔸
⊢ c' * d = c' * d + c x * 0
Theorem: Int.isUnit_iff_natAbs_eq
File: Mathlib/Data/Int/Units.lean

tactic: simp [natAbs_eq_iff, isUnit_iff, Nat.cast_zero]
state_before: n : ℤ
⊢ IsUnit n ↔ natAbs n = 1
Theorem: TopologicalSpace.IsTopologicalBasis.insert_empty
File: Mathlib/Topology/Bases.lean

tactic: refine' ⟨_, by rw [sUnion_insert, empty_union, h.sUnion_eq], _⟩
state_before: α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ IsTopologicalBasis (insert ∅ s)

tactic: rw [sUnion_insert, empty_union, h.sUnion_eq]
state_before: α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ ⋃₀ insert ∅ s = univ

tactic: rintro t₁ (rfl | h₁) t₂ (rfl | h₂) x ⟨hx₁, hx₂⟩
state_before: case refine'_1
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ ∀ (t₁ : Set α),
    t₁ ∈ insert ∅ s →
      ∀ (t₂ : Set α), t₂ ∈ insert ∅ s → ∀ (x : α), x ∈ t₁ ∩ t₂ → ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: cases hx₁
state_before: case refine'_1.inl.inl.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
x : α
hx₁ hx₂ : x ∈ ∅
⊢ ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ ∅ ∩ ∅

tactic: cases hx₁
state_before: case refine'_1.inl.inr.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₂ : Set α
h₂ : t₂ ∈ s
x : α
hx₁ : x ∈ ∅
hx₂ : x ∈ t₂
⊢ ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ ∅ ∩ t₂

tactic: cases hx₂
state_before: case refine'_1.inr.inl.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₁ : Set α
h₁ : t₁ ∈ s
x : α
hx₁ : x ∈ t₁
hx₂ : x ∈ ∅
⊢ ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ ∅

tactic: obtain ⟨t₃, h₃, hs⟩ := h.exists_subset_inter _ h₁ _ h₂ x ⟨hx₁, hx₂⟩
state_before: case refine'_1.inr.inr.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₁ : Set α
h₁ : t₁ ∈ s
t₂ : Set α
h₂ : t₂ ∈ s
x : α
hx₁ : x ∈ t₁
hx₂ : x ∈ t₂
⊢ ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: exact ⟨t₃, .inr h₃, hs⟩
state_before: case refine'_1.inr.inr.intro.intro.intro
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t₁ : Set α
h₁ : t₁ ∈ s
t₂ : Set α
h₂ : t₂ ∈ s
x : α
hx₁ : x ∈ t₁
hx₂ : x ∈ t₂
t₃ : Set α
h₃ : t₃ ∈ s
hs : x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
⊢ ∃ t₃, t₃ ∈ insert ∅ s ∧ x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

tactic: rw [h.eq_generateFrom]
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ t = generateFrom (insert ∅ s)

tactic: refine' le_antisymm (le_generateFrom fun t => _) (generateFrom_anti <| subset_insert ∅ s)
state_before: case refine'_2
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ generateFrom s = generateFrom (insert ∅ s)

tactic: rintro (rfl | ht)
state_before: case refine'_2
α : Type u
t✝ : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t : Set α
⊢ t ∈ insert ∅ s → IsOpen t

tactic: exact @isOpen_empty _ (generateFrom s)
state_before: case refine'_2.inl
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ IsOpen ∅

tactic: exact .basic t ht
state_before: case refine'_2.inr
α : Type u
t✝ : TopologicalSpace α
s : Set (Set α)
h : IsTopologicalBasis s
t : Set α
ht : t ∈ s
⊢ IsOpen t
Theorem: HasFTaylorSeriesUpToOn.contDiffOn
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: intro x hx m hm
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 f' : E → FormalMultilinearSeries 𝕜 E F
hf : HasFTaylorSeriesUpToOn n f f' s
⊢ ContDiffOn 𝕜 n f s

tactic: use s
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 f' : E → FormalMultilinearSeries 𝕜 E F
hf : HasFTaylorSeriesUpToOn n f f' s
x : E
hx : x ∈ s
m : ℕ
hm : ↑m ≤ n
⊢ ∃ u, u ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p u

tactic: simp only [Set.insert_eq_of_mem hx, self_mem_nhdsWithin, true_and_iff]
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 f' : E → FormalMultilinearSeries 𝕜 E F
hf : HasFTaylorSeriesUpToOn n f f' s
x : E
hx : x ∈ s
m : ℕ
hm : ↑m ≤ n
⊢ s ∈ 𝓝[insert x s] x ∧ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p s

tactic: exact ⟨f', hf.of_le hm⟩
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 f' : E → FormalMultilinearSeries 𝕜 E F
hf : HasFTaylorSeriesUpToOn n f f' s
x : E
hx : x ∈ s
m : ℕ
hm : ↑m ≤ n
⊢ ∃ p, HasFTaylorSeriesUpToOn (↑m) f p s
Theorem: IsROrC.conj_neg_I
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [map_neg, conj_I, neg_neg]
state_before: K : Type u_1
E : Type ?u.2812841
inst✝ : IsROrC K
⊢ ↑(starRingEnd K) (-I) = I
Theorem: MeasureTheory.measure_eq_div_smul
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: ext1 t ht
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hs : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ μ = (↑↑μ s / ↑↑ν s) • ν

tactic: rw [smul_apply, smul_eq_mul, mul_comm, ← mul_div_assoc, mul_comm,
  measure_mul_measure_eq μ ν hs ht h2s h3s, mul_div_assoc, ENNReal.mul_div_cancel' h2s h3s]
state_before: case h
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hs : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
t : Set G
ht : MeasurableSet t
⊢ ↑↑μ t = ↑↑((↑↑μ s / ↑↑ν s) • ν) t
Theorem: MonoidAlgebra.single_mul_apply_of_not_exists_mul
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [mul_apply, Finsupp.sum_single_index]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ ↑(single g r * x) g' = 0

tactic: swap
state_before: k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ (sum x fun a₂ b₂ => if g * a₂ = g' then r * b₂ else 0) = 0

k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ (sum x fun a₂ b₂ => if g * a₂ = g' then 0 * b₂ else 0) = 0

tactic: simp_rw [Finsupp.sum, MulZeroClass.zero_mul, ite_self, Finset.sum_const_zero]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ (sum x fun a₂ b₂ => if g * a₂ = g' then 0 * b₂ else 0) = 0

tactic: apply Finset.sum_eq_zero
state_before: k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ (sum x fun a₂ b₂ => if g * a₂ = g' then r * b₂ else 0) = 0

tactic: simp_rw [ite_eq_right_iff]
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ ∀ (x_1 : G), x_1 ∈ x.support → (fun a₂ b₂ => if g * a₂ = g' then r * b₂ else 0) x_1 (↑x x_1) = 0

tactic: rintro g'' _hg'' rfl
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = g * d
⊢ ∀ (x_1 : G), x_1 ∈ x.support → g * x_1 = g' → r * ↑x x_1 = 0

tactic: exfalso
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g : G
x : MonoidAlgebra k G
g'' : G
_hg'' : g'' ∈ x.support
h : ¬∃ d, g * g'' = g * d
⊢ r * ↑x g'' = 0

tactic: exact h ⟨_, rfl⟩
state_before: case h.h
k : Type u₁
G : Type u₂
R : Type ?u.524025
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g : G
x : MonoidAlgebra k G
g'' : G
_hg'' : g'' ∈ x.support
h : ¬∃ d, g * g'' = g * d
⊢ False
Theorem: isClosed_of_closure_subset
File: Mathlib/Topology/Basic.lean

tactic: rw [subset_closure.antisymm h]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : closure s ⊆ s
⊢ IsClosed s

tactic: exact isClosed_closure
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : closure s ⊆ s
⊢ IsClosed (closure s)
Theorem: MeasureTheory.FiniteMeasure.toMeasure_normalize_eq_of_nonzero
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: ext1 s _s_mble
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
⊢ ↑(normalize μ) = ↑((mass μ)⁻¹ • μ)

tactic: rw [← μ.normalize.ennreal_coeFn_eq_coeFn_toMeasure s, μ.normalize_eq_of_nonzero nonzero s,
  ENNReal.coe_mul, ennreal_coeFn_eq_coeFn_toMeasure]
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
s : Set Ω
_s_mble : MeasurableSet s
⊢ ↑↑↑(normalize μ) s = ↑↑↑((mass μ)⁻¹ • μ) s

tactic: exact Measure.coe_nnreal_smul_apply _ _ _
state_before: case h
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
s : Set Ω
_s_mble : MeasurableSet s
⊢ ↑(mass μ)⁻¹ * ↑↑↑μ s = ↑↑↑((mass μ)⁻¹ • μ) s
Theorem: lowerClosure_mul
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: simp_rw [mul_comm _ t]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ↑(lowerClosure s) * t = ↑(lowerClosure (s * t))

tactic: exact mul_lowerClosure _ _
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ t * ↑(lowerClosure s) = ↑(lowerClosure (t * s))
Theorem: Asymptotics.isEquivalent_zero_iff_isBigO_zero
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: refine' ⟨IsEquivalent.isBigO, fun h ↦ _⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] 0 ↔ u =O[l] 0

tactic: rw [isEquivalent_zero_iff_eventually_zero, eventuallyEq_iff_exists_mem]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u =O[l] 0
⊢ u ~[l] 0

tactic: exact ⟨{ x : α | u x = 0 }, isBigO_zero_right_iff.mp h, fun x hx ↦ hx⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u =O[l] 0
⊢ ∃ s, s ∈ l ∧ Set.EqOn u 0 s
Theorem: List.chain'_isInfix
File: Mathlib/Data/List/Chain.lean

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ a b : α
l : List α
⊢ [] ++ [a, b] ++ l = a :: b :: l

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ a b : α
l : List α
x y : α
h : [x, y] <:+: b :: l
⊢ [a] ++ b :: l ++ [] = a :: b :: l
Theorem: dist_smul_le
File: Mathlib/Analysis/Normed/MulAction.lean

tactic: simpa only [dist_eq_norm, sub_zero] using dist_smul_pair s x y
state_before: α : Type u_2
β : Type u_1
inst✝³ : SeminormedAddGroup α
inst✝² : SeminormedAddGroup β
inst✝¹ : SMulZeroClass α β
inst✝ : BoundedSMul α β
s : α
x y : β
⊢ dist (s • x) (s • y) ≤ ‖s‖ * dist x y
Theorem: Unique.subsingleton_unique'
File: Mathlib/Logic/Unique.lean

tactic: congr
state_before: α : Sort u_1
x : α
h : ∀ (a : α), a = default
y : α
uniq✝ : ∀ (a : α), a = default
⊢ { toInhabited := { default := x }, uniq := h } = { toInhabited := { default := y }, uniq := uniq✝ }

tactic: rw [h x, h y]
state_before: case e_toInhabited.e_default
α : Sort u_1
x : α
h : ∀ (a : α), a = default
y : α
uniq✝ : ∀ (a : α), a = default
⊢ x = y
Theorem: hasSum_single
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa using this
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.38564
δ : Type ?u.38567
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b✝ : α
s : Finset β
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 0
this : HasSum f (∑ b' in {b}, f b')
⊢ HasSum f (f b)

tactic: simpa [hf]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.38564
δ : Type ?u.38567
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b✝ : α
s : Finset β
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 0
⊢ ∀ (b_1 : β), ¬b_1 ∈ {b} → f b_1 = 0
Theorem: Polynomial.monomial_neg
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [eq_neg_iff_add_eq_zero, ← monomial_add, neg_add_self, monomial_zero_right]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
a : R
⊢ ↑(monomial n) (-a) = -↑(monomial n) a
Theorem: LinearMap.exists_monic_and_aeval_eq_zero
File: Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean

tactic: simp
state_before: ι : Type ?u.205232
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_1
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : Module.Finite R M
f : Module.End R M
⊢ range f ≤ ⊤ • ⊤
Theorem: LinearMap.separatingRight_iff_flip_ker_eq_bot
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [← flip_separatingLeft, separatingLeft_iff_ker_eq_bot]
state_before: R : Type u_2
R₁ : Type u_1
R₂ : Type u_5
R₃ : Type ?u.566808
M : Type ?u.566811
M₁ : Type u_3
M₂ : Type u_4
Mₗ₁ : Type ?u.566820
Mₗ₁' : Type ?u.566823
Mₗ₂ : Type ?u.566826
Mₗ₂' : Type ?u.566829
K : Type ?u.566832
K₁ : Type ?u.566835
K₂ : Type ?u.566838
V : Type ?u.566841
V₁ : Type ?u.566844
V₂ : Type ?u.566847
n : Type ?u.566850
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : CommSemiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
I₁ : R₁ →+* R
I₂ : R₂ →+* R
I₁' : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] R
⊢ SeparatingRight B ↔ ker (flip B) = ⊥
Theorem: MvQPF.Fix.dest_mk
File: Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean

tactic: unfold Fix.dest
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ dest (mk x) = x

tactic: rw [Fix.rec_eq, ← Fix.dest, ← comp_map]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ rec (MvFunctor.map (TypeVec.id ::: mk)) (mk x) = x

tactic: conv =>
  rhs
  rw [← MvFunctor.id_map x]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = x

tactic: rw [← appendFun_comp, id_comp]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ ((TypeVec.id ::: mk) ⊚ (TypeVec.id ::: dest)) <$$> x = TypeVec.id <$$> x

tactic: have : Fix.mk ∘ Fix.dest = _root_.id := by
  ext (x: Fix F α)
  apply Fix.mk_dest
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x

tactic: rw [this, appendFun_id_id]
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
this : mk ∘ dest = _root_.id
⊢ (TypeVec.id ::: mk ∘ dest) <$$> x = TypeVec.id <$$> x

tactic: ext (x: Fix F α)
state_before: n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x : F (α ::: Fix F α)
⊢ mk ∘ dest = _root_.id

tactic: apply Fix.mk_dest
state_before: case h
n : ℕ
F : TypeVec (n + 1) → Type u
inst✝ : MvFunctor F
q : MvQPF F
α : TypeVec n
x✝ : F (α ::: Fix F α)
x : Fix F α
⊢ (mk ∘ dest) x = _root_.id x
Theorem: Set.ite_left
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Set.ite]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ Set.ite s s t = s ∪ t
Theorem: Real.sqrt_lt'
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_lt_sqrt_iff_of_pos (pow_pos hy _), sqrt_sq hy.le]
state_before: x y : ℝ
hy : 0 < y
⊢ sqrt x < y ↔ x < y ^ 2
Theorem: Function.partialInv_of_injective
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [hpi, dif_pos h'] at h
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
a : α
b : β
h : partialInv f b = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
⊢ f a = b

tactic: injection h with h
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : some (Classical.choose h') = some a
⊢ f a = b

tactic: subst h
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
a : α
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
h : Classical.choose h' = a
⊢ f a = b

tactic: apply Classical.choose_spec h'
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
b : β
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ∃ a, f a = b
⊢ f (Classical.choose h') = b

tactic: rw [hpi, dif_neg h'] at h
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
a : α
b : β
h : partialInv f b = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ¬∃ a, f a = b
⊢ f a = b

tactic: contradiction
state_before: α✝ : Sort ?u.12530
β✝ : Sort ?u.12533
γ : Sort ?u.12536
f✝ : α✝ → β✝
α : Type u_1
β : Sort u_2
f : α → β
I : Injective f
a : α
b : β
h : none = some a
hpi : partialInv f b = if h : ∃ a, f a = b then some (Classical.choose h) else none
h' : ¬∃ a, f a = b
⊢ f a = b
Theorem: List.prod_hom_rel
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp only [map_cons, prod_cons, h₂ hl]
state_before: ι : Type u_1
α : Type ?u.19416
M : Type u_2
N : Type u_3
P : Type ?u.19425
M₀ : Type ?u.19428
G : Type ?u.19431
R : Type ?u.19434
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝¹ l₁ l₂ : List M
a✝ : M
l✝ : List ι
r : M → N → Prop
f : ι → M
g : ι → N
h₁ : r 1 1
h₂ : ∀ ⦃i : ι⦄ ⦃a : M⦄ ⦃b : N⦄, r a b → r (f i * a) (g i * b)
a : ι
l : List ι
hl : r (prod (map f l)) (prod (map g l))
⊢ r (prod (map f (a :: l))) (prod (map g (a :: l)))