tasksource/leandojo huggingface dataset:
Theorem: balancedCoreAux_empty
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: simp_rw [balancedCoreAux, iInter₂_eq_empty_iff, smul_set_empty]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.37359
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
⊢ balancedCoreAux 𝕜 ∅ = ∅

tactic: exact fun _ => ⟨1, norm_one.ge, not_mem_empty _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.37359
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
⊢ ∀ (a : E), ∃ i h, ¬a ∈ ∅
Theorem: Complex.differentiableOn_compl_singleton_and_continuousAt_iff
File: Mathlib/Analysis/Complex/RemovableSingularity.lean

tactic: refine' ⟨_, fun hd => ⟨hd.mono (diff_subset _ _), (hd.differentiableAt hs).continuousAt⟩⟩
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
⊢ DifferentiableOn ℂ f (s \ {c}) ∧ ContinuousAt f c ↔ DifferentiableOn ℂ f s

tactic: rintro ⟨hd, hc⟩ x hx
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
⊢ DifferentiableOn ℂ f (s \ {c}) ∧ ContinuousAt f c → DifferentiableOn ℂ f s

tactic: rcases eq_or_ne x c with (rfl | hne)
state_before: case intro
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
hd : DifferentiableOn ℂ f (s \ {c})
hc : ContinuousAt f c
x : ℂ
hx : x ∈ s
⊢ DifferentiableWithinAt ℂ f s x

tactic: refine' (analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt
  _ hc).differentiableAt.differentiableWithinAt
state_before: case intro.inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
x : ℂ
hx : x ∈ s
hs : s ∈ 𝓝 x
hd : DifferentiableOn ℂ f (s \ {x})
hc : ContinuousAt f x
⊢ DifferentiableWithinAt ℂ f s x

tactic: refine' eventually_nhdsWithin_iff.2 ((eventually_mem_nhds.2 hs).mono fun z hz hzx => _)
state_before: case intro.inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
x : ℂ
hx : x ∈ s
hs : s ∈ 𝓝 x
hd : DifferentiableOn ℂ f (s \ {x})
hc : ContinuousAt f x
⊢ ∀ᶠ (z : ℂ) in 𝓝[{x}ᶜ] x, DifferentiableAt ℂ f z

tactic: exact hd.differentiableAt (inter_mem hz (isOpen_ne.mem_nhds hzx))
state_before: case intro.inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
x : ℂ
hx : x ∈ s
hs : s ∈ 𝓝 x
hd : DifferentiableOn ℂ f (s \ {x})
hc : ContinuousAt f x
z : ℂ
hz : s ∈ 𝓝 z
hzx : z ∈ {x}ᶜ
⊢ DifferentiableAt ℂ f z

tactic: simpa only [DifferentiableWithinAt, HasFDerivWithinAt, hne.nhdsWithin_diff_singleton] using
  hd x ⟨hx, hne⟩
state_before: case intro.inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
s : Set ℂ
c : ℂ
hs : s ∈ 𝓝 c
hd : DifferentiableOn ℂ f (s \ {c})
hc : ContinuousAt f c
x : ℂ
hx : x ∈ s
hne : x ≠ c
⊢ DifferentiableWithinAt ℂ f s x
Theorem: CategoryTheory.Limits.pullback.diagonal_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: apply pullback.hom_ext <;> simp
state_before: C : Type u_2
inst✝⁸ : Category C
X Y Z : C
inst✝⁷ : HasPullbacks C
S T : C
f✝ : X ⟶ T
g✝ : Y ⟶ T
i : T ⟶ S
inst✝⁶ : HasPullback i i
inst✝⁵ : HasPullback f✝ g✝
inst✝⁴ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝³ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasPullback f f
inst✝¹ : HasPullback g g
inst✝ : HasPullback (f ≫ g) (f ≫ g)
⊢ diagonal (f ≫ g) = diagonal f ≫ (pullbackDiagonalMapIdIso f f g).inv ≫ snd
Theorem: Subgroup.IsComplement'.isCompl
File: Mathlib/GroupTheory/Complement.lean

tactic: refine'
  ⟨disjoint_iff_inf_le.mpr fun g ⟨p, q⟩ =>
      let x : H × K := ⟨⟨g, p⟩, 1⟩
      let y : H × K := ⟨1, g, q⟩
      Subtype.ext_iff.mp
        (Prod.ext_iff.mp (show x = y from h.1 ((mul_one g).trans (one_mul g).symm))).1,
    codisjoint_iff_le_sup.mpr fun g _ => _⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement' H K
⊢ IsCompl H K

tactic: obtain ⟨⟨h, k⟩, rfl⟩ := h.2 g
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement' H K
g : G
x✝ : g ∈ ⊤
⊢ g ∈ H ⊔ K

tactic: exact Subgroup.mul_mem_sup h.2 k.2
state_before: case intro.mk
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h✝ : IsComplement' H K
h : ↑↑H
k : ↑↑K
x✝ : (fun x => ↑x.fst * ↑x.snd) (h, k) ∈ ⊤
⊢ (fun x => ↑x.fst * ↑x.snd) (h, k) ∈ H ⊔ K
Theorem: Num.cast_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← to_nat_to_int, Int.cast_ofNat, cast_to_nat]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : Num
⊢ ↑↑n = ↑n
Theorem: SimpleGraph.Walk.IsPath.of_cons
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [isPath_def]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : Adj G u v
p : Walk G v w
⊢ IsPath (cons h p) → IsPath p
Theorem: add_tsub_le_assoc
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, add_left_comm]
state_before: α : Type u_1
β : Type ?u.7101
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b - c ≤ a + (b - c)

tactic: exact add_le_add_left le_add_tsub a
state_before: α : Type u_1
β : Type ?u.7101
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b ≤ a + (c + (b - c))
Theorem: Basis.card_le_card_of_linearIndependent_aux
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa using linearIndependent_le_basis (Pi.basisFun R (Fin n)) v h
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.373329
R✝ : Type u
inst✝⁵ : Ring R✝
inst✝⁴ : StrongRankCondition R✝
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Module R✝ M
R : Type u_1
inst✝¹ : Ring R
inst✝ : StrongRankCondition R
n m : ℕ
v : Fin m → Fin n → R
h : LinearIndependent R v
⊢ m ≤ n
Theorem: BoundedContinuousFunction.nnnorm_eq_iSup_nnnorm
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp_rw [val_eq_coe, NNReal.coe_iSup, coe_nnnorm]
state_before: F : Type ?u.1063529
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
⊢ (⨆ (x : α), ‖↑f x‖) = ↑(⨆ (x : α), ‖↑f x‖₊)
Theorem: ENNReal.toReal_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← ENNReal.ofReal_coe_nat n, ENNReal.toReal_ofReal (Nat.cast_nonneg _)]
state_before: α : Type ?u.103317
β : Type ?u.103320
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ ENNReal.toReal ↑n = ↑n
Theorem: MonoidAlgebra.mul_apply_antidiagonal
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: ext
state_before: k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
⊢ Finset.filter (fun p => p.fst * p.snd = x) (f.support ×ˢ g.support) =
    Finset.filter (fun p => p.fst ∈ f.support ∧ p.snd ∈ g.support) s

tactic: simp only [mem_filter, mem_product, hs, and_comm]
state_before: case a
k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
a✝ : G × G
⊢ a✝ ∈ Finset.filter (fun p => p.fst * p.snd = x) (f.support ×ˢ g.support) ↔
    a✝ ∈ Finset.filter (fun p => p.fst ∈ f.support ∧ p.snd ∈ g.support) s

tactic: simp only [mem_filter, mem_support_iff, not_and, Classical.not_not] at hp⊢
state_before: k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
p : G × G
hps : p ∈ s
hp : ¬p ∈ Finset.filter (fun p => p.fst ∈ f.support ∧ p.snd ∈ g.support) s
⊢ ↑f p.fst * ↑g p.snd = 0

tactic: by_cases h1 : f p.1 = 0
state_before: k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
p : G × G
hps : p ∈ s
hp : p ∈ s → ↑f p.fst ≠ 0 → ↑g p.snd = 0
⊢ ↑f p.fst * ↑g p.snd = 0

tactic: rw [h1, zero_mul]
state_before: case pos
k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
p : G × G
hps : p ∈ s
hp : p ∈ s → ↑f p.fst ≠ 0 → ↑g p.snd = 0
h1 : ↑f p.fst = 0
⊢ ↑f p.fst * ↑g p.snd = 0

tactic: rw [hp hps h1, mul_zero]
state_before: case neg
k : Type u₁
G : Type u₂
R : Type ?u.357749
inst✝¹ : Semiring k
inst✝ : Mul G
f g : MonoidAlgebra k G
x : G
s : Finset (G × G)
hs : ∀ {p : G × G}, p ∈ s ↔ p.fst * p.snd = x
F : G × G → k := fun p => if p.fst * p.snd = x then ↑f p.fst * ↑g p.snd else 0
p : G × G
hps : p ∈ s
hp : p ∈ s → ↑f p.fst ≠ 0 → ↑g p.snd = 0
h1 : ¬↑f p.fst = 0
⊢ ↑f p.fst * ↑g p.snd = 0
Theorem: Filter.zero_smul_filter_nonpos
File: Mathlib/Order/Filter/Pointwise.lean

tactic: refine' fun s hs => mem_smul_filter.2 _
state_before: F : Type ?u.441163
α : Type u_2
β : Type u_1
γ : Type ?u.441172
δ : Type ?u.441175
ε : Type ?u.441178
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
⊢ 0 • g ≤ 0

tactic: convert @univ_mem _ g
state_before: F : Type ?u.441163
α : Type u_2
β : Type u_1
γ : Type ?u.441172
δ : Type ?u.441175
ε : Type ?u.441178
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
s : Set β
hs : s ∈ 0
⊢ (fun x x_1 => x • x_1) 0 ⁻¹' s ∈ g

tactic: refine' eq_univ_iff_forall.2 fun a => _
state_before: case h.e'_4
F : Type ?u.441163
α : Type u_2
β : Type u_1
γ : Type ?u.441172
δ : Type ?u.441175
ε : Type ?u.441178
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
s : Set β
hs : s ∈ 0
⊢ (fun x x_1 => x • x_1) 0 ⁻¹' s = univ

tactic: dsimp only
state_before: case h.e'_4
F : Type ?u.441163
α : Type u_2
β : Type u_1
γ : Type ?u.441172
δ : Type ?u.441175
ε : Type ?u.441178
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
s : Set β
hs : s ∈ 0
a : β
⊢ a ∈ (fun x x_1 => x • x_1) 0 ⁻¹' s

tactic: rwa [mem_preimage, zero_smul]
state_before: case h.e'_4
F : Type ?u.441163
α : Type u_2
β : Type u_1
γ : Type ?u.441172
δ : Type ?u.441175
ε : Type ?u.441178
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
s : Set β
hs : s ∈ 0
a : β
⊢ a ∈ (fun x => 0 • x) ⁻¹' s
Theorem: Equiv.Perm.SameCycle.toList_isRotated
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: by_cases hx : x ∈ f.support
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
⊢ toList f x ~r toList f y

tactic: obtain ⟨_ | k, _, hy⟩ := h.exists_pow_eq_of_mem_support hx
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : x ∈ support f
⊢ toList f x ~r toList f y

tactic: use k.succ
state_before: case pos.intro.succ.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : x ∈ support f
k : ℕ
w✝ : Nat.succ k < Finset.card (support (cycleOf f x))
hy : ↑(f ^ Nat.succ k) x = y
⊢ toList f x ~r toList f y

tactic: rw [← toList_pow_apply_eq_rotate, hy]
state_before: case pos.intro.succ.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : x ∈ support f
k : ℕ
w✝ : Nat.succ k < Finset.card (support (cycleOf f x))
hy : ↑(f ^ Nat.succ k) x = y
⊢ rotate (toList f x) (Nat.succ k) = toList f y

tactic: simp only [coe_one, id.def, pow_zero, Nat.zero_eq] at hy
state_before: case pos.intro.zero.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : x ∈ support f
w✝ : Nat.zero < Finset.card (support (cycleOf f x))
hy : ↑(f ^ Nat.zero) x = y
⊢ toList f x ~r toList f y

tactic: simp [hy, IsRotated.refl]
state_before: case pos.intro.zero.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : x ∈ support f
w✝ : Nat.zero < Finset.card (support (cycleOf f x))
hy : x = y
⊢ toList f x ~r toList f y

tactic: rw [toList_eq_nil_iff.mpr hx, isRotated_nil_iff', eq_comm, toList_eq_nil_iff]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : ¬x ∈ support f
⊢ toList f x ~r toList f y

tactic: rwa [← h.mem_support_iff]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x y : α
h : SameCycle f x y
hx : ¬x ∈ support f
⊢ ¬y ∈ support f
Theorem: Module.Finite.of_basis
File: Mathlib/LinearAlgebra/FreeModule/Finite/Basic.lean

tactic: cases nonempty_fintype ι
state_before: R✝ : Type u
M✝ : Type v
N : Type w
inst✝¹⁰ : CommRing R✝
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Free R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
inst✝⁴ : Free R✝ N
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : _root_.Finite ι
b : Basis ι R M
⊢ Finite R M

tactic: classical
  refine' ⟨⟨Finset.univ.image b, _⟩⟩
  simp only [Set.image_univ, Finset.coe_univ, Finset.coe_image, Basis.span_eq]
state_before: case intro
R✝ : Type u
M✝ : Type v
N : Type w
inst✝¹⁰ : CommRing R✝
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Free R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
inst✝⁴ : Free R✝ N
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : _root_.Finite ι
b : Basis ι R M
val✝ : Fintype ι
⊢ Finite R M

tactic: refine' ⟨⟨Finset.univ.image b, _⟩⟩
state_before: case intro
R✝ : Type u
M✝ : Type v
N : Type w
inst✝¹⁰ : CommRing R✝
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Free R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
inst✝⁴ : Free R✝ N
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : _root_.Finite ι
b : Basis ι R M
val✝ : Fintype ι
⊢ Finite R M

tactic: simp only [Set.image_univ, Finset.coe_univ, Finset.coe_image, Basis.span_eq]
state_before: case intro
R✝ : Type u
M✝ : Type v
N : Type w
inst✝¹⁰ : CommRing R✝
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Free R✝ M✝
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
inst✝⁴ : Free R✝ N
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : _root_.Finite ι
b : Basis ι R M
val✝ : Fintype ι
⊢ Submodule.span R ↑(Finset.image (↑b) Finset.univ) = ⊤
Theorem: MeasureTheory.VectorMeasure.MutuallySingular.smul_right
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: simp only [coe_smul, Pi.smul_apply, hs₂ t ht, smul_zero]
state_before: α : Type u_3
β : Type ?u.668179
m : MeasurableSpace α
L : Type ?u.668185
M : Type u_4
N : Type u_2
inst✝⁸ : AddCommMonoid L
inst✝⁷ : TopologicalSpace L
inst✝⁶ : AddCommMonoid M
inst✝⁵ : TopologicalSpace M
inst✝⁴ : AddCommMonoid N
inst✝³ : TopologicalSpace N
v v₁ v₂ : VectorMeasure α M
w w₁ w₂ : VectorMeasure α N
R : Type u_1
inst✝² : Semiring R
inst✝¹ : DistribMulAction R N
inst✝ : ContinuousConstSMul R N
r : R
h : v ⟂ᵥ w
s : Set α
hmeas : MeasurableSet s
hs₁ : ∀ (t : Set α), t ⊆ s → ↑v t = 0
hs₂ : ∀ (t : Set α), t ⊆ sᶜ → ↑w t = 0
t : Set α
ht : t ⊆ sᶜ
⊢ ↑(r • w) t = 0
Theorem: Multiset.single_le_prod
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simpa using List.single_le_prod hl x hx
state_before: ι : Type ?u.118660
α : Type u_1
β : Type ?u.118666
γ : Type ?u.118669
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
l : List α
hl : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) l → 1 ≤ x
x : α
hx : x ∈ Quotient.mk (List.isSetoid α) l
⊢ x ≤ prod (Quotient.mk (List.isSetoid α) l)
Theorem: Cardinal.mk_eq_two_iff'
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [mk_eq_two_iff]
state_before: α β : Type u
x : α
⊢ (#α) = 2 ↔ ∃! y, y ≠ x

tactic: constructor
state_before: α β : Type u
x : α
⊢ (∃ x y, x ≠ y ∧ {x, y} = univ) ↔ ∃! y, y ≠ x

tactic: rintro ⟨a, b, hne, h⟩
state_before: case mp
α β : Type u
x : α
⊢ (∃ x y, x ≠ y ∧ {x, y} = univ) → ∃! y, y ≠ x

tactic: simp only [eq_univ_iff_forall, mem_insert_iff, mem_singleton_iff] at h
state_before: case mp.intro.intro.intro
α β : Type u
x a b : α
hne : a ≠ b
h : {a, b} = univ
⊢ ∃! y, y ≠ x

tactic: rcases h x with (rfl | rfl)
state_before: case mp.intro.intro.intro
α β : Type u
x a b : α
hne : a ≠ b
h : ∀ (x : α), x = a ∨ x = b
⊢ ∃! y, y ≠ x

tactic: exacts [⟨b, hne.symm, fun z => (h z).resolve_left⟩, ⟨a, hne, fun z => (h z).resolve_right⟩]
state_before: case mp.intro.intro.intro.inl
α β : Type u
x b : α
hne : x ≠ b
h : ∀ (x_1 : α), x_1 = x ∨ x_1 = b
⊢ ∃! y, y ≠ x

case mp.intro.intro.intro.inr
α β : Type u
x a : α
hne : a ≠ x
h : ∀ (x_1 : α), x_1 = a ∨ x_1 = x
⊢ ∃! y, y ≠ x

tactic: rintro ⟨y, hne, hy⟩
state_before: case mpr
α β : Type u
x : α
⊢ (∃! y, y ≠ x) → ∃ x y, x ≠ y ∧ {x, y} = univ

tactic: exact ⟨x, y, hne.symm, eq_univ_of_forall fun z => or_iff_not_imp_left.2 (hy z)⟩
state_before: case mpr.intro.intro
α β : Type u
x y : α
hne : y ≠ x
hy : ∀ (y_1 : α), (fun y => y ≠ x) y_1 → y_1 = y
⊢ ∃ x y, x ≠ y ∧ {x, y} = univ
Theorem: PrimeSpectrum.primeSpectrumProd_symm_inl_asIdeal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: cases x
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum R
⊢ (↑(primeSpectrumProd R S).symm (Sum.inl x)).asIdeal = Ideal.prod x.asIdeal ⊤

tactic: rfl
state_before: case mk
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
asIdeal✝ : Ideal R
IsPrime✝ : Ideal.IsPrime asIdeal✝
⊢ (↑(primeSpectrumProd R S).symm (Sum.inl { asIdeal := asIdeal✝, IsPrime := IsPrime✝ })).asIdeal =
    Ideal.prod { asIdeal := asIdeal✝, IsPrime := IsPrime✝ }.asIdeal ⊤
Theorem: map_extChartAt_symm_nhdsWithin_range'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← extChartAt_source I]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.216667
M' : Type ?u.216670
H' : Type ?u.216673
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
y : M
hy : y ∈ (extChartAt I x).source
⊢ y ∈ (chartAt H x).toLocalEquiv.source
Theorem: integral_sin_pow_pos
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: rcases even_or_odd' n with ⟨k, rfl | rfl⟩ <;>
simp only [integral_sin_pow_even, integral_sin_pow_odd] <;>
refine' mul_pos (by norm_num <;> exact pi_pos) (prod_pos fun n _ => div_pos _ _) <;>
norm_cast <;>
linarith
state_before: a b : ℝ
n : ℕ
⊢ 0 < ∫ (x : ℝ) in 0 ..π, sin x ^ n

tactic: norm_num <;> exact pi_pos
state_before: a b : ℝ
k : ℕ
⊢ 0 < 2
Theorem: hammingNorm_smul
File: Mathlib/InformationTheory/Hamming.lean

tactic: simp_rw [smul_zero]
state_before: α : Type u_1
ι : Type u_3
β : ι → Type u_2
inst✝⁶ : Fintype ι
inst✝⁵ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.31631
inst✝⁴ : (i : ι) → DecidableEq (γ i)
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → Zero (γ i)
inst✝¹ : Zero α
inst✝ : (i : ι) → SMulWithZero α (β i)
k : α
hk : ∀ (i : ι), IsSMulRegular (β i) k
x : (i : ι) → β i
i : ι
⊢ (fun i c => k • c) i 0 = 0
Theorem: MeasureTheory.Memℒp.snorm_indicator_norm_ge_pos_le
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: obtain ⟨M, hM⟩ := hf.snorm_indicator_norm_ge_le μ hmeas hε
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
⊢ ∃ M, 0 < M ∧ snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε

tactic: refine'
  ⟨max M 1, lt_of_lt_of_le zero_lt_one (le_max_right _ _), le_trans (snorm_mono fun x => _) hM⟩
state_before: case intro
α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε
⊢ ∃ M, 0 < M ∧ snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε

tactic: rw [norm_indicator_eq_indicator_norm, norm_indicator_eq_indicator_norm]
state_before: case intro
α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε
x : α
⊢ ‖Set.indicator {x | max M 1 ≤ ↑‖f x‖₊} f x‖ ≤ ‖Set.indicator {x | M ≤ ↑‖f x‖₊} f x‖

tactic: refine' Set.indicator_le_indicator_of_subset (fun x hx => _) (fun x => norm_nonneg (f x)) x
state_before: case intro
α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε
x : α
⊢ Set.indicator {x | max M 1 ≤ ↑‖f x‖₊} (fun a => ‖f a‖) x ≤ Set.indicator {x | M ≤ ↑‖f x‖₊} (fun a => ‖f a‖) x

tactic: rw [Set.mem_setOf_eq] at hx
state_before: case intro
α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε
x✝ x : α
hx : x ∈ {x | max M 1 ≤ ↑‖f x‖₊}
⊢ x ∈ {x | M ≤ ↑‖f x‖₊}

tactic: exact (max_le_iff.1 hx).1
state_before: case intro
α : Type u_2
β : Type u_1
ι : Type ?u.118448
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f p
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : snorm (Set.indicator {x | M ≤ ↑‖f x‖₊} f) p μ ≤ ENNReal.ofReal ε
x✝ x : α
hx : max M 1 ≤ ↑‖f x‖₊
⊢ x ∈ {x | M ≤ ↑‖f x‖₊}
Theorem: Composition.sum_blocksFun
File: Mathlib/Combinatorics/Composition.lean

tactic: conv_rhs => rw [← c.blocks_sum, ← ofFn_blocksFun, sum_ofFn]
state_before: n : ℕ
c : Composition n
⊢ ∑ i : Fin (length c), blocksFun c i = n