tasksource/leandojo huggingface dataset:
Theorem: VectorFourier.fourierIntegral_smul_const
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: ext1 w
state_before: 𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
r : ℂ
⊢ fourierIntegral e μ L (r • f) = r • fourierIntegral e μ L f

tactic: simp only [Pi.smul_apply, fourierIntegral, ← integral_smul]
state_before: case h
𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
r : ℂ
w : W
⊢ fourierIntegral e μ L (r • f) w = (r • fourierIntegral e μ L f) w

tactic: congr
state_before: case h
𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
r : ℂ
w : W
⊢ (∫ (v : V), ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L v) w))) • r • f v ∂μ) =
    ∫ (a : V), r • ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L a) w))) • f a ∂μ

tactic: funext
state_before: case h.e_f
𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
r : ℂ
w : W
⊢ (fun v => ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L v) w))) • r • f v) = fun a =>
    r • ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L a) w))) • f a

tactic: rw [smul_comm]
state_before: case h.e_f.h
𝕜 : Type u_1
inst✝⁸ : CommRing 𝕜
V : Type u_2
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module 𝕜 V
inst✝⁵ : MeasurableSpace V
W : Type u_3
inst✝⁴ : AddCommGroup W
inst✝³ : Module 𝕜 W
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
e : Multiplicative 𝕜 →* { x // x ∈ 𝕊 }
μ : MeasureTheory.Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
f : V → E
r : ℂ
w : W
x✝ : V
⊢ ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L x✝) w))) • r • f x✝ = r • ↑(↑e (↑Multiplicative.ofAdd (-↑(↑L x✝) w))) • f x✝
Theorem: rank_span_of_finset
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [Finset.coe_sort_coe, Cardinal.mk_coe_finset]
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.570799
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Finset V
⊢ (#↑↑s) = ↑(Finset.card s)
Theorem: wittPolynomial_zero
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: simp only [wittPolynomial, X, sum_singleton, range_one, pow_zero, zero_add, tsub_self]
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.103907
inst✝ : CommRing S
⊢ W_ R 0 = X 0
Theorem: derivWithin_add_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simp only [derivWithin, fderivWithin_add_const hxs]
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 : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => f y + c) s x = derivWithin f s x
Theorem: Stream'.WSeq.destruct_some_of_destruct_tail_some
File: Mathlib/Data/Seq/WSeq.lean

tactic: unfold tail Functor.map at h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
h : some a ∈ destruct (tail s)
⊢ ∃ a', some a' ∈ destruct s

tactic: simp at h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
h : some a ∈ destruct (flatten (Applicative.toFunctor.1 (fun o => Option.recOn o nil Prod.snd) (destruct s)))
⊢ ∃ a', some a' ∈ destruct s

tactic: rcases exists_of_mem_bind h with ⟨t, tm, td⟩
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
h : some a ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) (destruct s) >>= destruct
⊢ ∃ a', some a' ∈ destruct s

tactic: clear h
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
h : some a ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) (destruct s) >>= destruct
t : WSeq α
tm : t ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) (destruct s)
td : some a ∈ destruct t
⊢ ∃ a', some a' ∈ destruct s

tactic: rcases Computation.exists_of_mem_map tm with ⟨t', ht', ht2⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
tm : t ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) (destruct s)
td : some a ∈ destruct t
⊢ ∃ a', some a' ∈ destruct s

tactic: clear tm
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
tm : t ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) (destruct s)
td : some a ∈ destruct t
t' : Option (α × WSeq α)
ht' : t' ∈ destruct s
ht2 : Option.rec nil Prod.snd t' = t
⊢ ∃ a', some a' ∈ destruct s

tactic: cases' t' with t' <;> rw [← ht2] at td <;> simp at td
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
td : some a ∈ destruct t
t' : Option (α × WSeq α)
ht' : t' ∈ destruct s
ht2 : Option.rec nil Prod.snd t' = t
⊢ ∃ a', some a' ∈ destruct s

tactic: have := mem_unique td (ret_mem _)
state_before: case intro.intro.intro.intro.none
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
ht' : none ∈ destruct s
ht2 : Option.rec nil Prod.snd none = t
td : some a ∈ Computation.pure none
⊢ ∃ a', some a' ∈ destruct s

tactic: contradiction
state_before: case intro.intro.intro.intro.none
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
ht' : none ∈ destruct s
ht2 : Option.rec nil Prod.snd none = t
td : some a ∈ Computation.pure none
this : some a = none
⊢ ∃ a', some a' ∈ destruct s

tactic: exact ⟨_, ht'⟩
state_before: case intro.intro.intro.intro.some
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α × WSeq α
t : WSeq α
t' : α × WSeq α
td : some a ∈ destruct t'.snd
ht' : some t' ∈ destruct s
ht2 : Option.rec nil Prod.snd (some t') = t
⊢ ∃ a', some a' ∈ destruct s
Theorem: Finset.biUnion_singleton
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_biUnion, mem_image, mem_singleton, eq_comm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.122048
inst✝ : DecidableEq β
f✝ g : α → β
s : Finset α
t : Finset β
a : α
b c : β
f : α → β
x : β
⊢ (x ∈ Finset.biUnion s fun a => {f a}) ↔ x ∈ image f s
Theorem: Finset.card_memberSubfamily_add_card_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: rw [memberSubfamily, nonMemberSubfamily, card_image_of_injOn]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ card (memberSubfamily a 𝒜) + card (nonMemberSubfamily a 𝒜) = card 𝒜

tactic: conv_rhs => rw [← filter_card_add_filter_neg_card_eq_card (fun s => (a ∈ s))]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ card (filter (fun s => a ∈ s) 𝒜) + card (filter (fun s => ¬a ∈ s) 𝒜) = card 𝒜

tactic: apply (erase_injOn' _).mono
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ Set.InjOn (fun s => erase s a) ↑(filter (fun s => a ∈ s) 𝒜)

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ ↑(filter (fun s => a ∈ s) 𝒜) ⊆ {s | a ∈ s}
Theorem: Complex.closure_setOf_lt_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [closure_Ioi] using closure_preimage_re (Ioi a)
state_before: a : ℝ
⊢ closure {z | a < z.re} = {z | a ≤ z.re}
Theorem: PartitionOfUnity.exists_pos
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: have H := f.sum_eq_one hx
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type ?u.14392
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set X
f : PartitionOfUnity ι X s
x : X
hx : x ∈ s
⊢ ∃ i, 0 < ↑(toFun s f i) x

tactic: contrapose! H
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type ?u.14392
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set X
f : PartitionOfUnity ι X s
x : X
hx : x ∈ s
H : (∑ᶠ (i : ι), ↑(toFun s f i) x) = 1
⊢ ∃ i, 0 < ↑(toFun s f i) x

tactic: simp_rw [not_exists, not_lt] at H
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type ?u.14392
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set X
f : PartitionOfUnity ι X s
x : X
hx : x ∈ s
H : ¬∃ i, 0 < ↑(toFun s f i) x
⊢ (∑ᶠ (i : ι), ↑(toFun s f i) x) ≠ 1

tactic: simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type ?u.14392
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set X
f : PartitionOfUnity ι X s
x : X
hx : x ∈ s
H : ∀ (x_1 : ι), ↑(toFun s f x_1) x ≤ 0
⊢ (∑ᶠ (i : ι), ↑(toFun s f i) x) ≠ 1
Theorem: Gamma1_to_Gamma0_mem
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: constructor
state_before: N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
⊢ A ∈ Gamma1' N ↔ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: intro ha
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
⊢ A ∈ Gamma1' N → ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: have hA := A.property
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : A ∈ Gamma1' N
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: rw [Gamma0_mem] at hA
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : A ∈ Gamma1' N
hA : ↑A ∈ Gamma0 N
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: have adet := Gamma0_det N A
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : A ∈ Gamma1' N
hA : ↑(↑↑A 1 0) = 0
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: rw [Matrix.det_fin_two] at adet
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : A ∈ Gamma1' N
hA : ↑(↑↑A 1 0) = 0
adet : ↑(det ↑↑A) = 1
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: simp only [Gamma0Map, coe_matrix_coe, Int.coe_castRingHom, map_apply, Gamma1_mem',
  MonoidHom.coe_mk, OneHom.coe_mk, Int.cast_sub, Int.cast_mul] at *
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : A ∈ Gamma1' N
hA : ↑(↑↑A 1 0) = 0
adet : ↑(↑↑A 0 0 * ↑↑A 1 1 - ↑↑A 0 1 * ↑↑A 1 0) = 1
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: rw [hA, ha] at adet
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
hA : ↑(↑↑A 1 0) = 0
ha : ↑(↑↑A 1 1) = 1
adet : ↑(↑↑A 0 0) * ↑(↑↑A 1 1) - ↑(↑↑A 0 1) * ↑(↑↑A 1 0) = 1
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: simp only [mul_one, MulZeroClass.mul_zero, sub_zero] at adet
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
hA : ↑(↑↑A 1 0) = 0
ha : ↑(↑↑A 1 1) = 1
adet : ↑(↑↑A 0 0) * 1 - ↑(↑↑A 0 1) * 0 = 1
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: simp only [adet, hA, ha, eq_self_iff_true, and_self_iff]
state_before: case mp
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
hA : ↑(↑↑A 1 0) = 0
ha : ↑(↑↑A 1 1) = 1
adet : ↑(↑↑A 0 0) = 1
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0

tactic: intro ha
state_before: case mpr
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
⊢ ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0 → A ∈ Gamma1' N

tactic: simp only [Gamma1_mem', Gamma0Map, MonoidHom.coe_mk, coe_matrix_coe,
  Int.coe_castRingHom, map_apply]
state_before: case mpr
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0
⊢ A ∈ Gamma1' N

tactic: exact ha.2.1
state_before: case mpr
N✝ N : ℕ
A : { x // x ∈ Gamma0 N }
ha : ↑(↑↑A 0 0) = 1 ∧ ↑(↑↑A 1 1) = 1 ∧ ↑(↑↑A 1 0) = 0
⊢ ↑{ toFun := fun g => ↑(↑↑g 1 1), map_one' := (_ : ↑(OfNat.ofNat 1 1 1) = 1) } A = 1
Theorem: subset_interior_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [subset_def, mem_interior_iff_mem_nhds]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s V : Set α
⊢ s ⊆ interior V ↔ ∀ (x : α), x ∈ s → V ∈ 𝓝 x
Theorem: linearIndependent_iff
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [LinearIndependent, LinearMap.ker_eq_bot']
state_before: ι : Type u'
ι' : Type ?u.1463
R : Type u_1
K : Type ?u.1469
M : Type u_2
M' : Type ?u.1475
M'' : Type ?u.1478
V : Type u
V' : Type ?u.1483
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
⊢ LinearIndependent R v ↔ ∀ (l : ι →₀ R), ↑(Finsupp.total ι M R v) l = 0 → l = 0
Theorem: Fin.card_Iio
File: Mathlib/Data/Fin/Interval.lean

tactic: rw [← Nat.card_Iio b, ← map_valEmbedding_Iio, card_map]
state_before: n : ℕ
a b : Fin n
⊢ card (Iio b) = ↑b
Theorem: Int.exists_prime_and_dvd
File: Mathlib/RingTheory/Int/Basic.lean

tactic: obtain ⟨p, pp, pd⟩ := Nat.exists_prime_and_dvd hn
state_before: n : ℤ
hn : natAbs n ≠ 1
⊢ ∃ p, Prime p ∧ p ∣ n

tactic: exact ⟨p, Nat.prime_iff_prime_int.mp pp, Int.coe_nat_dvd_left.mpr pd⟩
state_before: case intro.intro
n : ℤ
hn : natAbs n ≠ 1
p : ℕ
pp : Nat.Prime p
pd : p ∣ natAbs n
⊢ ∃ p, Prime p ∧ p ∣ n
Theorem: MeasureTheory.JordanDecomposition.toSignedMeasure_smul
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: ext1 i hi
state_before: α : Type u_1
β : Type ?u.19420
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ≥0
⊢ toSignedMeasure (r • j) = r • toSignedMeasure j

tactic: rw [VectorMeasure.smul_apply, toSignedMeasure, toSignedMeasure,
  toSignedMeasure_sub_apply hi, toSignedMeasure_sub_apply hi, smul_sub, smul_posPart,
  smul_negPart, ← ENNReal.toReal_smul, ← ENNReal.toReal_smul, smul_toOuterMeasure,
  OuterMeasure.coe_smul, Pi.smul_apply, smul_toOuterMeasure, OuterMeasure.coe_smul, Pi.smul_apply]
state_before: case h
α : Type u_1
β : Type ?u.19420
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ≥0
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure (r • j)) i = ↑(r • toSignedMeasure j) i
Theorem: MeasureTheory.measure_smul_average
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: cases' eq_or_ne μ 0 with hμ hμ
state_before: α : Type u_1
E : Type u_2
F : Type ?u.190069
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
⊢ (ENNReal.toReal (↑↑μ univ) • ⨍ (x : α), f x ∂μ) = ∫ (x : α), f x ∂μ

tactic: rw [hμ, integral_zero_measure, average_zero_measure, smul_zero]
state_before: case inl
α : Type u_1
E : Type u_2
F : Type ?u.190069
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
hμ : μ = 0
⊢ (ENNReal.toReal (↑↑μ univ) • ⨍ (x : α), f x ∂μ) = ∫ (x : α), f x ∂μ

tactic: rw [average_eq, smul_inv_smul₀]
state_before: case inr
α : Type u_1
E : Type u_2
F : Type ?u.190069
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
hμ : μ ≠ 0
⊢ (ENNReal.toReal (↑↑μ univ) • ⨍ (x : α), f x ∂μ) = ∫ (x : α), f x ∂μ

tactic: refine' (ENNReal.toReal_pos _ <| measure_ne_top _ _).ne'
state_before: case inr.hc
α : Type u_1
E : Type u_2
F : Type ?u.190069
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
hμ : μ ≠ 0
⊢ ENNReal.toReal (↑↑μ univ) ≠ 0

tactic: rwa [Ne.def, measure_univ_eq_zero]
state_before: case inr.hc
α : Type u_1
E : Type u_2
F : Type ?u.190069
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : Measure α
s : Set E
inst✝ : IsFiniteMeasure μ
f : α → E
hμ : μ ≠ 0
⊢ ↑↑μ univ ≠ 0
Theorem: SimpleGraph.Subgraph.induce_mono
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: constructor
state_before: ι : Sort ?u.258280
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ induce G' s ≤ induce G'' s'

tactic: simp [hs]
state_before: case left
ι : Sort ?u.258280
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ (induce G' s).verts ⊆ (induce G'' s').verts

tactic: simp (config := { contextual := true }) only [induce_Adj, true_and_iff, and_imp]
state_before: case right
ι : Sort ?u.258280
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, Adj (induce G' s) v w → Adj (induce G'' s') v w

tactic: intro v w hv hw ha
state_before: case right
ι : Sort ?u.258280
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, v ∈ s → w ∈ s → Adj G' v w → v ∈ s' ∧ w ∈ s' ∧ Adj G'' v w

tactic: exact ⟨hs hv, hs hw, hg.2 ha⟩
state_before: case right
ι : Sort ?u.258280
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
v w : V
hv : v ∈ s
hw : w ∈ s
ha : Adj G' v w
⊢ v ∈ s' ∧ w ∈ s' ∧ Adj G'' v w
Theorem: CategoryTheory.IsPushout.of_map
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine' ⟨⟨e⟩, ⟨isColimitOfReflects F <| _⟩⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsColimit (span f g) F
e : f ≫ h = g ≫ i
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ IsPushout f g h i

tactic: refine'
  (IsColimit.equivOfNatIsoOfIso (spanCompIso F f g) _ _ (WalkingSpan.ext _ _ _)).symm
    H.isColimit
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsColimit (span f g) F
e : f ≫ h = g ≫ i
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ IsColimit (F.mapCocone (PushoutCocone.mk h i (_ : f ≫ h = g ≫ i)))

tactic: exacts [Iso.refl _, (Category.comp_id _).trans (Category.id_comp _),
  (Category.comp_id _).trans (Category.id_comp _)]
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsColimit (span f g) F
e : f ≫ h = g ≫ i
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cocones.precompose (spanCompIso F f g).inv).obj (F.mapCocone (PushoutCocone.mk h i (_ : f ≫ h = g ≫ i)))).pt ≅
    (cocone H).pt

case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsColimit (span f g) F
e : f ≫ h = g ≫ i
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cocones.precompose (spanCompIso F f g).inv).obj (F.mapCocone (PushoutCocone.mk h i (_ : f ≫ h = g ≫ i)))).ι.app
        WalkingCospan.left ≫
      ?refine'_1.hom =
    (cocone H).ι.app WalkingCospan.left

case refine'_3
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : ReflectsColimit (span f g) F
e : f ≫ h = g ≫ i
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ ((Cocones.precompose (spanCompIso F f g).inv).obj (F.mapCocone (PushoutCocone.mk h i (_ : f ≫ h = g ≫ i)))).ι.app
        WalkingCospan.right ≫
      ?refine'_1.hom =
    (cocone H).ι.app WalkingCospan.right
Theorem: Mathlib.Meta.NormNum.IsRat.of_raw
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : DivisionRing α
n : ℤ
d : ℕ
h : ↑d ≠ 0
this : Invertible ↑d
⊢ Rat.rawCast n d = ↑n * ⅟↑d
Theorem: Orthonormal.inner_finsupp_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [Finsupp.mem_supported'] at hl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2141610
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
s : Set ι
i : ι
hi : ¬i ∈ s
l : ι →₀ 𝕜
hl : l ∈ Finsupp.supported 𝕜 𝕜 s
⊢ inner (↑(Finsupp.total ι E 𝕜 v) l) (v i) = 0

tactic: simp only [hv.inner_left_finsupp, hl i hi, map_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2141610
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
s : Set ι
i : ι
hi : ¬i ∈ s
l : ι →₀ 𝕜
hl : ∀ (x : ι), ¬x ∈ s → ↑l x = 0
⊢ inner (↑(Finsupp.total ι E 𝕜 v) l) (v i) = 0