tasksource/leandojo huggingface dataset:
Theorem: smul_pi_subset
File: Mathlib/Algebra/Module/PointwisePi.lean

tactic: rintro x ⟨y, h, rfl⟩ i hi
state_before: K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
s : Set ι
t : (i : ι) → Set (R i)
⊢ r • pi s t ⊆ pi s (r • t)

tactic: exact smul_mem_smul_set (h i hi)
state_before: case intro.intro
K : Type u_1
ι : Type u_3
R : ι → Type u_2
inst✝ : (i : ι) → SMul K (R i)
r : K
s : Set ι
t : (i : ι) → Set (R i)
y : (i : ι) → R i
h : y ∈ pi s t
i : ι
hi : i ∈ s
⊢ (fun x => r • x) y i ∈ (r • t) i
Theorem: ChainComplex.to_single₀_ext
File: Mathlib/Algebra/Homology/Single.lean

tactic: ext
state_before: V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f g : C ⟶ (single₀ V).obj X
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(toSingle₀Equiv C X) f = ↑(toSingle₀Equiv C X) g

tactic: exact h
state_before: case a
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f g : C ⟶ (single₀ V).obj X
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(↑(toSingle₀Equiv C X) f) = ↑(↑(toSingle₀Equiv C X) g)
Theorem: Basis.det_reindex
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: rw [Basis.det_apply, Basis.toMatrix_reindex', det_reindexAlgEquiv, Basis.det_apply]
state_before: R : Type u_3
inst✝¹⁰ : CommRing R
M : Type u_4
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.2694483
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2695503
inst✝³ : CommRing A
inst✝² : Module A M
ι' : Type u_1
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
⊢ ↑(det (reindex b e)) v = ↑(det b) (v ∘ ↑e)
Theorem: List.not_perm_nil_cons
File: Mathlib/Data/List/Perm.lean

tactic: injection p.symm.eq_nil
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
x : α
l : List α
x✝ : [] ~ x :: l
p : [] ~ x :: l := x✝
⊢ False
Theorem: Nat.ModEq.pow
File: Mathlib/Data/Nat/ModEq.lean

tactic: induction m with
| zero => rfl
| succ d hd =>
  rw[pow_succ, pow_succ]
  exact hd.mul h
state_before: m✝ n a b c d m : ℕ
h : a ≡ b [MOD n]
⊢ a ^ m ≡ b ^ m [MOD n]

tactic: rfl
state_before: case zero
m n a b c d : ℕ
h : a ≡ b [MOD n]
⊢ a ^ zero ≡ b ^ zero [MOD n]

tactic: rw[pow_succ, pow_succ]
state_before: case succ
m n a b c d✝ : ℕ
h : a ≡ b [MOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [MOD n]
⊢ a ^ succ d ≡ b ^ succ d [MOD n]

tactic: exact hd.mul h
state_before: case succ
m n a b c d✝ : ℕ
h : a ≡ b [MOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [MOD n]
⊢ a ^ d * a ≡ b ^ d * b [MOD n]
Theorem: PadicSeq.norm_eq_of_add_equiv_zero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have : LimZero (f + g - 0) := h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
⊢ norm f = norm g

tactic: have : f ≈ -g := show LimZero (f - -g) by simpa only [sub_zero, sub_neg_eq_add]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this : LimZero (f + g - 0)
⊢ norm f = norm g

tactic: have : f.norm = (-g).norm := norm_equiv this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝ : LimZero (f + g - 0)
this : f ≈ -g
⊢ norm f = norm g

tactic: simpa only [norm_neg] using this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝¹ : LimZero (f + g - 0)
this✝ : f ≈ -g
this : norm f = norm (-g)
⊢ norm f = norm g

tactic: simpa only [sub_zero, sub_neg_eq_add]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this : LimZero (f + g - 0)
⊢ LimZero (f - -g)
Theorem: Finset.Iio_insert
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.118371
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderBot α
inst✝ : DecidableEq α
b : α
⊢ insert b (Iio b) = Iic b

tactic: simp_rw [Finset.mem_insert, mem_Iic, mem_Iio, le_iff_lt_or_eq, or_comm]
state_before: case a
ι : Type ?u.118371
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrderBot α
inst✝ : DecidableEq α
b a✝ : α
⊢ a✝ ∈ insert b (Iio b) ↔ a✝ ∈ Iic b
Theorem: Monotone.tendsto_leftLim
File: Mathlib/Topology/Algebra/Order/LeftRightLim.lean

tactic: rcases eq_or_ne (𝓝[<] x) ⊥ with (h' | h')
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
⊢ Tendsto f (𝓝[Iio x] x) (𝓝 (leftLim f x))

tactic: rw [leftLim_eq_sSup hf h']
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[Iio x] x ≠ ⊥
⊢ Tendsto f (𝓝[Iio x] x) (𝓝 (leftLim f x))

tactic: exact hf.tendsto_nhdsWithin_Iio x
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[Iio x] x ≠ ⊥
⊢ Tendsto f (𝓝[Iio x] x) (𝓝 (sSup (f '' Iio x)))

tactic: simp [h']
state_before: case inl
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[Iio x] x = ⊥
⊢ Tendsto f (𝓝[Iio x] x) (𝓝 (leftLim f x))
Theorem: Prod.one_mk_mul_one_mk
File: Mathlib/Algebra/Group/Prod.lean

tactic: rw [mk_mul_mk, mul_one]
state_before: A : Type ?u.1848
B : Type ?u.1851
G : Type ?u.1854
H : Type ?u.1857
M : Type u_1
N : Type u_2
P : Type ?u.1866
inst✝¹ : Monoid M
inst✝ : Mul N
b₁ b₂ : N
⊢ (1, b₁) * (1, b₂) = (1, b₁ * b₂)
Theorem: List.dropLast_take
File: Mathlib/Data/List/Basic.lean

tactic: simp [dropLast_eq_take, min_eq_left_of_lt h, take_take, pred_le]
state_before: ι : Type ?u.197224
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
l : List α
h : n < length l
⊢ dropLast (take n l) = take (pred n) l
Theorem: List.infix_concat
File: Std/Data/List/Lemmas.lean

tactic: simp [← h, concat_eq_append, append_assoc]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
a : α✝
x✝ : l₁ <:+: l₂
L₁ L₂ : List α✝
h : L₁ ++ l₁ ++ L₂ = l₂
⊢ L₁ ++ l₁ ++ concat L₂ a = concat l₂ a
Theorem: Path.map_id
File: Mathlib/Topology/PathConnected.lean

tactic: ext
state_before: X : Type u_1
Y : Type ?u.306480
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.306495
γ✝ γ : Path x y
⊢ map γ (_ : Continuous id) = γ

tactic: rfl
state_before: case a.h
X : Type u_1
Y : Type ?u.306480
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.306495
γ✝ γ : Path x y
x✝ : ↑I
⊢ ↑(map γ (_ : Continuous id)) x✝ = ↑γ x✝
Theorem: Finsupp.indicator_apply
File: Mathlib/Data/Finsupp/Indicator.lean

tactic: simp only [indicator, ne_eq, coe_mk]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
inst✝ : DecidableEq ι
⊢ ↑(indicator s f) i = if hi : i ∈ s then f i hi else 0

tactic: congr
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
inst✝ : DecidableEq ι
⊢ (if H : i ∈ s then f i H else 0) = if hi : i ∈ s then f i hi else 0
Theorem: MeasureTheory.AEEqFun.inf_le_left
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← coeFn_le]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.463632
δ : Type ?u.463635
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ f ⊓ g ≤ f

tactic: filter_upwards [coeFn_inf f g] with _ ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.463632
δ : Type ?u.463635
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ ↑(f ⊓ g) ≤ᵐ[μ] ↑f

tactic: rw [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.463632
δ : Type ?u.463635
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑(f ⊓ g) a✝ ≤ ↑f a✝

tactic: exact inf_le_left
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.463632
δ : Type ?u.463635
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑f a✝ ⊓ ↑g a✝ ≤ ↑f a✝
Theorem: Rat.sub_def'
File: Std/Data/Rat/Lemmas.lean

tactic: rw [sub_def, normalize_eq_mkRat]
state_before: a b : Rat
⊢ a - b = mkRat (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den)
Theorem: Nat.mul_pred_right
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.mul_comm, mul_pred_left, Nat.mul_comm]
state_before: n m : Nat
⊢ n * pred m = n * m - n
Theorem: LieModule.isNilpotent_range_toEndomorphism_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: constructor <;> rintro ⟨k, hk⟩ <;> use k <;>
    rw [← LieSubmodule.coe_toSubmodule_eq_iff] at hk ⊢ <;>
  simpa using hk
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 : LieSubmodule R L M
⊢ IsNilpotent R { x // x ∈ LieHom.range (toEndomorphism R L M) } M ↔ IsNilpotent R L M
Theorem: Zsqrtd.mul_nonneg
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp_rw [← nonneg_iff_zero_le]
state_before: d : ℕ
a b : ℤ√↑d
⊢ 0 ≤ a → 0 ≤ b → 0 ≤ a * b

tactic: exact nonneg_mul
state_before: d : ℕ
a b : ℤ√↑d
⊢ Nonneg a → Nonneg b → Nonneg (a * b)
Theorem: Cardinal.is_prime_iff
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

tactic: cases' le_or_lt ℵ₀ a with h h
state_before: a✝ b : Cardinal
n m : ℕ
a : Cardinal
⊢ Prime a ↔ ℵ₀ ≤ a ∨ ∃ p, a = ↑p ∧ Nat.Prime p

tactic: lift a to ℕ using id h
state_before: case inr
a✝ b : Cardinal
n m : ℕ
a : Cardinal
h : a < ℵ₀
⊢ Prime a ↔ ℵ₀ ≤ a ∨ ∃ p, a = ↑p ∧ Nat.Prime p

tactic: simp [not_le.mpr h]
state_before: case inr.intro
a✝ b : Cardinal
n m a : ℕ
h : ↑a < ℵ₀
⊢ Prime ↑a ↔ ℵ₀ ≤ ↑a ∨ ∃ p, ↑a = ↑p ∧ Nat.Prime p

tactic: simp [h]
state_before: case inl
a✝ b : Cardinal
n m : ℕ
a : Cardinal
h : ℵ₀ ≤ a
⊢ Prime a ↔ ℵ₀ ≤ a ∨ ∃ p, a = ↑p ∧ Nat.Prime p
Theorem: FiberBundleCore.localTrivAt_apply
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: rw [localTrivAt, localTriv_apply, coordChange_self]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type ?u.44757
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b : B
a : F
p : TotalSpace Z
⊢ ↑(localTrivAt Z p.fst) p = (p.fst, p.snd)

tactic: exact Z.mem_baseSet_at p.1
state_before: case a
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type ?u.44757
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b : B
a : F
p : TotalSpace Z
⊢ p.fst ∈ baseSet Z (indexAt Z p.fst)
Theorem: MeasureTheory.trim_measurableSet_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [Measure.trim, toMeasure_apply (ms := m) _ _ hs]
state_before: α : Type u_1
β : Type ?u.3496903
γ : Type ?u.3496906
δ : Type ?u.3496909
ι : Type ?u.3496912
R : Type ?u.3496915
R' : Type ?u.3496918
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
hs : MeasurableSet s
⊢ ↑↑(trim μ hm) s = ↑↑μ s
Theorem: MeasureTheory.SignedMeasure.subset_negative_null_set
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [← s.neg_le_neg_iff _ hu, neg_zero] at hsu
state_before: α : Type u_1
β : Type ?u.51571
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict s u ≤ VectorMeasure.restrict 0 u
hw₁ : ↑s w = 0
hw₂ : w ⊆ u
hwt : v ⊆ w
⊢ ↑s v = 0

tactic: have := subset_positive_null_set hu hv hw hsu
state_before: α : Type u_1
β : Type ?u.51571
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hw₁ : ↑s w = 0
hw₂ : w ⊆ u
hwt : v ⊆ w
⊢ ↑s v = 0

tactic: simp only [Pi.neg_apply, neg_eq_zero, coe_neg] at this
state_before: α : Type u_1
β : Type ?u.51571
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hw₁ : ↑s w = 0
hw₂ : w ⊆ u
hwt : v ⊆ w
this : ↑(-s) w = 0 → w ⊆ u → v ⊆ w → ↑(-s) v = 0
⊢ ↑s v = 0

tactic: exact this hw₁ hw₂ hwt
state_before: α : Type u_1
β : Type ?u.51571
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hw : MeasurableSet w
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hw₁ : ↑s w = 0
hw₂ : w ⊆ u
hwt : v ⊆ w
this : ↑s w = 0 → w ⊆ u → v ⊆ w → ↑s v = 0
⊢ ↑s v = 0
Theorem: String.data_join
File: Std/Data/String/Lemmas.lean

tactic: rw [join_eq]
state_before: ss : List String
⊢ (join ss).data = List.join (List.map data ss)
Theorem: mem_balancedCore_iff
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: simp_rw [balancedCore, mem_sUnion, mem_setOf_eq, and_assoc]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.1285
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s t : Set E
x : E
⊢ x ∈ balancedCore 𝕜 s ↔ ∃ t, Balanced 𝕜 t ∧ t ⊆ s ∧ x ∈ t
Theorem: Dfinsupp.toFinsupp_single
File: Mathlib/Data/Finsupp/ToDfinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type ?u.8500
M : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
i : ι
m : M
⊢ toFinsupp (single i m) = Finsupp.single i m

tactic: simp [Finsupp.single_apply, Dfinsupp.single_apply]
state_before: case h
ι : Type u_1
R : Type ?u.8500
M : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
i : ι
m : M
a✝ : ι
⊢ ↑(toFinsupp (single i m)) a✝ = ↑(Finsupp.single i m) a✝
Theorem: Option.orElse_none'
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u_1
β : Type ?u.15955
γ : Type ?u.15958
δ : Type ?u.15961
x : Option α
⊢ (Option.orElse x fun x => none) = x
Theorem: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_integral_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [map_integral f norm hf norm_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type ?u.197555
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.197657
F' : Type ?u.197660
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
T : Set α → E →L[ℝ] F
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ E
hf : Integrable ↑f
⊢ C * ∑ x in SimpleFunc.range f, ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖ = C * integral μ (map norm f)

tactic: simp_rw [smul_eq_mul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type ?u.197555
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.197657
F' : Type ?u.197660
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
T : Set α → E →L[ℝ] F
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → ‖T s‖ ≤ C * ENNReal.toReal (↑↑μ s)
f : α →ₛ E
hf : Integrable ↑f
⊢ C * ∑ x in SimpleFunc.range f, ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) * ‖x‖ =
    C * ∑ x in SimpleFunc.range f, ENNReal.toReal (↑↑μ (↑f ⁻¹' {x})) • ‖x‖
Theorem: subset_interior_iff_mem_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

tactic: simp_rw [mem_nhdsSet_iff_forall, subset_interior_iff_nhds]
state_before: α : Type u_1
β : Type ?u.7780
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
⊢ s ⊆ interior t ↔ t ∈ 𝓝ˢ s
Theorem: WithZeroTopology.singleton_mem_nhds_of_units
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: simp
state_before: α : Type ?u.39250
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ✝ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
γ : Γ₀ˣ
⊢ {↑γ} ∈ 𝓝 ↑γ
Theorem: Polynomial.coeff_zero_eq_eval_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
⊢ coeff p 0 = coeff p 0 * 0 ^ 0

tactic: symm
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
⊢ coeff p 0 * 0 ^ 0 = eval 0 p

tactic: rw [eval_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
⊢ eval 0 p = coeff p 0 * 0 ^ 0

tactic: exact
  Finset.sum_eq_single _ (fun b _ hb => by simp [zero_pow (Nat.pos_of_ne_zero hb)]) (by simp)
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
⊢ (sum p fun e a => a * 0 ^ e) = coeff p 0 * 0 ^ 0

tactic: simp [zero_pow (Nat.pos_of_ne_zero hb)]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
b : ℕ
x✝ : b ∈ support p
hb : b ≠ 0
⊢ (fun e a => a * 0 ^ e) b (coeff p b) = 0

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x : R
p : R[X]
⊢ ¬0 ∈ support p → (fun e a => a * 0 ^ e) 0 (coeff p 0) = 0
Theorem: UniqueFactorizationMonoid.normalizedFactors_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

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

tactic: refine' Associated.trans _ (Classical.choose_spec (exists_prime_factors a ane0)).2
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Multiset.prod
      (Multiset.map (↑normalize) (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))) ~ᵤ
    a

tactic: rw [← Associates.mk_eq_mk_iff_associated, ← Associates.prod_mk, ← Associates.prod_mk,
  Multiset.map_map]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Multiset.prod
      (Multiset.map (↑normalize) (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))) ~ᵤ
    Multiset.prod (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))

tactic: congr 2
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Multiset.prod
      (Multiset.map (Associates.mk ∘ ↑normalize)
        (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a))) =
    Multiset.prod
      (Multiset.map Associates.mk (Classical.choose (_ : ∃ f, (∀ (b : α), b ∈ f → Prime b) ∧ Multiset.prod f ~ᵤ a)))

tactic: ext
state_before: case e_a.e_f
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Associates.mk ∘ ↑normalize = Associates.mk

tactic: rw [Function.comp_apply, Associates.mk_normalize]
state_before: case e_a.e_f.h
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
x✝ : α
⊢ (Associates.mk ∘ ↑normalize) x✝ = Associates.mk x✝
Theorem: zero_prodMap_dualTensorHom
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext <;>
  simp only [coe_comp, coe_inr, Function.comp_apply, prodMap_apply, dualTensorHom_apply,
    snd_apply, Prod.smul_mk, LinearMap.zero_apply, smul_zero]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
g : Dual R N
q : Q
⊢ prodMap 0 (↑(dualTensorHom R N Q) (g ⊗ₜ[R] q)) =
    ↑(dualTensorHom R (M × N) (P × Q)) (comp g (snd R M N) ⊗ₜ[R] ↑(inr R P Q) q)
Theorem: LinearIndependent.coe_range
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simpa using i.comp _ (rangeSplitting_injective v)
state_before: ι : Type u'
ι' : Type ?u.97322
R : Type u_1
K : Type ?u.97328
M : Type u_2
M' : Type ?u.97334
M'' : Type ?u.97337
V : Type u
V' : Type ?u.97342
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
i : LinearIndependent R v
⊢ LinearIndependent R Subtype.val
Theorem: isωSup_ωSup
File: Mathlib/Topology/OmegaCompletePartialOrder.lean

tactic: constructor
state_before: α : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
⊢ IsωSup c (ωSup c)

tactic: apply le_ωSup
state_before: case left
α : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
⊢ ∀ (i : ℕ), ↑c i ≤ ωSup c

tactic: apply ωSup_le
state_before: case right
α : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
⊢ ∀ (y : α), (∀ (i : ℕ), ↑c i ≤ y) → ωSup c ≤ y
Theorem: Subgroup.mul_mem_iff_of_index_two
File: Mathlib/GroupTheory/Index.lean

tactic: by_cases ha : a ∈ H
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

tactic: by_cases hb : b ∈ H
state_before: case neg
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

tactic: simp only [ha, hb, iff_self_iff, iff_true_iff]
state_before: case neg
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
hb : ¬b ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

tactic: rcases index_eq_two_iff.1 h with ⟨c, hc⟩
state_before: case neg
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
hb : ¬b ∈ H
⊢ a * b ∈ H

tactic: refine' (hc _).or.resolve_left _
state_before: case neg.intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
hb : ¬b ∈ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ a * b ∈ H

tactic: rwa [mul_assoc, mul_mem_cancel_right ((hc _).or.resolve_right hb)]
state_before: case neg.intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
hb : ¬b ∈ H
c : G
hc : ∀ (b : G), Xor' (b * c ∈ H) (b ∈ H)
⊢ ¬a * b * c ∈ H

tactic: simp only [ha, true_iff_iff, mul_mem_cancel_left ha]
state_before: case pos
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : a ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)

tactic: simp only [hb, iff_true_iff, mul_mem_cancel_right hb]
state_before: case pos
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
h : index H = 2
a b : G
ha : ¬a ∈ H
hb : b ∈ H
⊢ a * b ∈ H ↔ (a ∈ H ↔ b ∈ H)
Theorem: smul_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ x • closedBall 1 δ = closedBall x δ