tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.haar.chaar_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: let eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
⊢ chaar K₀ ⊥ = 0

tactic: have : Continuous eval := continuous_apply ⊥
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
⊢ chaar K₀ ⊥ = 0

tactic: show chaar K₀ ∈ eval ⁻¹' {(0 : ℝ)}
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ⊥ = 0

tactic: apply mem_of_subset_of_mem _ (chaar_mem_clPrehaar K₀ ⊤)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ∈ eval ⁻¹' {0}

tactic: unfold clPrehaar
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ clPrehaar ↑K₀ ⊤ ⊆ eval ⁻¹' {0}

tactic: rw [IsClosed.closure_subset_iff]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ closure (prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U}) ⊆ eval ⁻¹' {0}

tactic: rintro _ ⟨U, _, rfl⟩
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U} ⊆ eval ⁻¹' {0}

tactic: apply prehaar_empty
state_before: case intro.intro
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
U : Set G
left✝ : U ∈ {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U}
⊢ prehaar (↑K₀) U ∈ eval ⁻¹' {0}

tactic: apply continuous_iff_isClosed.mp this
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ IsClosed (eval ⁻¹' {0})

tactic: exact isClosed_singleton
state_before: case a
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ IsClosed {0}
Theorem: Set.pi_def
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.281523
γ : Type ?u.281526
ι : Sort ?u.281529
ι' : Sort ?u.281532
ι₂ : Sort ?u.281535
κ : ι → Sort ?u.281540
κ₁ : ι → Sort ?u.281545
κ₂ : ι → Sort ?u.281550
κ' : ι' → Sort ?u.281555
π : α → Type u_2
i : Set α
s : (a : α) → Set (π a)
⊢ pi i s = ⋂ (a : α) (_ : a ∈ i), eval a ⁻¹' s a

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.281523
γ : Type ?u.281526
ι : Sort ?u.281529
ι' : Sort ?u.281532
ι₂ : Sort ?u.281535
κ : ι → Sort ?u.281540
κ₁ : ι → Sort ?u.281545
κ₂ : ι → Sort ?u.281550
κ' : ι' → Sort ?u.281555
π : α → Type u_2
i : Set α
s : (a : α) → Set (π a)
x✝ : (i : α) → π i
⊢ x✝ ∈ pi i s ↔ x✝ ∈ ⋂ (a : α) (_ : a ∈ i), eval a ⁻¹' s a
Theorem: Set.mulIndicator_union_of_not_mem_inter
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: rw [← mulIndicator_union_mul_inter_apply f s t, mulIndicator_of_not_mem h, mul_one]
state_before: α : Type u_1
β : Type ?u.49319
ι : Type ?u.49322
M : Type u_2
N : Type ?u.49328
inst✝ : MulOneClass M
s t : Set α
f✝ g : α → M
a : α
h : ¬a ∈ s ∩ t
f : α → M
⊢ mulIndicator (s ∪ t) f a = mulIndicator s f a * mulIndicator t f a
Theorem: List.map_id'
File: Mathlib/Data/List/Basic.lean

tactic: simp [show f = id from funext h]
state_before: ι : Type ?u.133026
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
h : ∀ (x : α), f x = x
l : List α
⊢ map f l = l
Theorem: Nat.unpair_lt
File: Mathlib/Data/Nat/Pairing.lean

tactic: let s := sqrt n
state_before: n : ℕ
n1 : 1 ≤ n
⊢ (unpair n).fst < n

tactic: simp [unpair]
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
⊢ (unpair n).fst < n

tactic: by_cases h : n - s * s < s <;> simp [h]
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
⊢ (if n - sqrt n * sqrt n < sqrt n then (n - sqrt n * sqrt n, sqrt n) else (sqrt n, n - sqrt n * sqrt n - sqrt n)).fst <
    n

tactic: exact lt_of_lt_of_le h (sqrt_le_self _)
state_before: case pos
n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
h : n - s * s < s
⊢ n - sqrt n * sqrt n < n

tactic: simp at h
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
h : ¬n - s * s < s
⊢ sqrt n < n

tactic: have s0 : 0 < s := sqrt_pos.2 n1
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
h : sqrt n ≤ n - sqrt n * sqrt n
⊢ sqrt n < n

tactic: exact lt_of_le_of_lt h (tsub_lt_self n1 (mul_pos s0 s0))
state_before: case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := sqrt n
h : sqrt n ≤ n - sqrt n * sqrt n
s0 : 0 < s
⊢ sqrt n < n
Theorem: CategoryTheory.Limits.cokernel.map_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : HasCokernel f✝
X Y Z X' Y' Z' : C
f : X ⟶ Y
inst✝¹ : HasCokernel f
g : Y ⟶ Z
w : f ≫ g = 0
f' : X' ⟶ Y'
inst✝ : HasCokernel f'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
p : X ⟶ X'
q : Y ⟶ Y'
r : Z ⟶ Z'
h₁ : f ≫ q = p ≫ f'
h₂ : g ≫ r = q ≫ g'
⊢ map f f' p q h₁ ≫ desc f' g' w' = desc f g w ≫ r

tactic: simp [h₂]
state_before: case h
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
inst✝² : HasCokernel f✝
X Y Z X' Y' Z' : C
f : X ⟶ Y
inst✝¹ : HasCokernel f
g : Y ⟶ Z
w : f ≫ g = 0
f' : X' ⟶ Y'
inst✝ : HasCokernel f'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
p : X ⟶ X'
q : Y ⟶ Y'
r : Z ⟶ Z'
h₁ : f ≫ q = p ≫ f'
h₂ : g ≫ r = q ≫ g'
⊢ coequalizer.π f 0 ≫ map f f' p q h₁ ≫ desc f' g' w' = coequalizer.π f 0 ≫ desc f g w ≫ r
Theorem: MeasurableSpace.measurableSet_sInf
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.27858
γ : Type ?u.27861
δ : Type ?u.27864
δ' : Type ?u.27867
ι : Sort ?u.27870
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ s ∈ ⋂₀ ((fun m => {t | MeasurableSet t}) '' ms) ↔ ∀ (m : MeasurableSpace α), m ∈ ms → MeasurableSet s
Theorem: Relation.ReflTransGen.swap
File: Mathlib/Logic/Relation.lean

tactic: induction' h with b c _ hbc ih
state_before: α : Type u_1
β : Type ?u.26665
γ : Type ?u.26668
δ : Type ?u.26671
r : α → α → Prop
a b c d : α
h : ReflTransGen r b a
⊢ ReflTransGen (Function.swap r) a b

tactic: rfl
state_before: case refl
α : Type u_1
β : Type ?u.26665
γ : Type ?u.26668
δ : Type ?u.26671
r : α → α → Prop
a b c d : α
⊢ ReflTransGen (Function.swap r) b b

tactic: exact ih.head hbc
state_before: case tail
α : Type u_1
β : Type ?u.26665
γ : Type ?u.26668
δ : Type ?u.26671
r : α → α → Prop
a b✝ c✝ d b c : α
a✝ : ReflTransGen r b✝ b
hbc : r b c
ih : ReflTransGen (Function.swap r) b b✝
⊢ ReflTransGen (Function.swap r) c b✝
Theorem: RegularExpression.map_pow
File: Mathlib/Computability/RegularExpressions.lean

tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.89298
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ map f (P ^ 0) = map f P ^ 0

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.89298
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ 1 = map f P ^ 0
Theorem: squarefree_iff_irreducible_sq_not_dvd_of_exists_irreducible
File: Mathlib/Algebra/Squarefree.lean

tactic: rw [irreducible_sq_not_dvd_iff_eq_zero_and_no_irreducibles_or_squarefree, ← not_exists]
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : ∃ x, Irreducible x
⊢ Squarefree r ↔ ∀ (x : R), Irreducible x → ¬x * x ∣ r

tactic: simp only [hr, not_true, false_or_iff, and_false_iff]
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : ∃ x, Irreducible x
⊢ Squarefree r ↔ (r = 0 ∧ ¬∃ x, Irreducible x) ∨ Squarefree r
Theorem: Polynomial.smul_eq_map
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

tactic: suffices DistribMulAction.toAddMonoidHom R[X] m =
    (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom by
  ext1 r
  exact FunLike.congr_fun this r
state_before: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
⊢ HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)

tactic: ext (n r) : 2
state_before: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
⊢ DistribMulAction.toAddMonoidHom R[X] m = RingHom.toAddMonoidHom (mapRingHom (MulSemiringAction.toRingHom M R m))

tactic: change m • monomial n r = map (MulSemiringAction.toRingHom M R m) (monomial n r)
state_before: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ ↑(AddMonoidHom.comp (DistribMulAction.toAddMonoidHom R[X] m) (LinearMap.toAddMonoidHom (monomial n))) r =
    ↑(AddMonoidHom.comp (RingHom.toAddMonoidHom (mapRingHom (MulSemiringAction.toRingHom M R m)))
          (LinearMap.toAddMonoidHom (monomial n)))
      r

tactic: rw [Polynomial.map_monomial, Polynomial.smul_monomial, MulSemiringAction.toRingHom_apply]
state_before: case h.h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
n : ℕ
r : R
⊢ m • ↑(monomial n) r = map (MulSemiringAction.toRingHom M R m) (↑(monomial n) r)

tactic: ext1 r
state_before: M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
this : DistribMulAction.toAddMonoidHom R[X] m = RingHom.toAddMonoidHom (mapRingHom (MulSemiringAction.toRingHom M R m))
⊢ HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)

tactic: exact FunLike.congr_fun this r
state_before: case h
M : Type u_1
inst✝² : Monoid M
R : Type u_2
inst✝¹ : Semiring R
inst✝ : MulSemiringAction M R
m : M
this : DistribMulAction.toAddMonoidHom R[X] m = RingHom.toAddMonoidHom (mapRingHom (MulSemiringAction.toRingHom M R m))
r : R[X]
⊢ m • r = map (MulSemiringAction.toRingHom M R m) r
Theorem: div_mul_div_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.46398
G : Type ?u.46401
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * (c / d) = a * c / (b * d)
Theorem: Combinatorics.Line.apply_of_ne_none
File: Mathlib/Combinatorics/HalesJewett.lean

tactic: rw [l.apply, Option.getD_of_ne_none h]
state_before: α : Type u_1
ι : Type u_2
l : Line α ι
x : α
i : ι
h : idxFun l i ≠ none
⊢ some ((fun x i => Option.getD (idxFun l i) x) x i) = idxFun l i
Theorem: Filter.IsBoundedUnder.bddAbove_range
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [← Nat.cofinite_eq_atTop] at hf
state_before: α : Type ?u.14057
β : Type u_1
γ : Type ?u.14063
ι : Type ?u.14066
r : α → α → Prop
f✝ g : Filter α
inst✝ : SemilatticeSup β
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) atTop f
⊢ BddAbove (range f)

tactic: exact hf.bddAbove_range_of_cofinite
state_before: α : Type ?u.14057
β : Type u_1
γ : Type ?u.14063
ι : Type ?u.14066
r : α → α → Prop
f✝ g : Filter α
inst✝ : SemilatticeSup β
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)
Theorem: GeneralizedContinuedFraction.exists_s_b_of_part_denom
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simpa [partialDenominators, Stream'.Seq.map_get?] using nth_part_denom_eq
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
b : α
nth_part_denom_eq : Stream'.Seq.get? (partialDenominators g) n = some b
⊢ ∃ gp, Stream'.Seq.get? g.s n = some gp ∧ gp.b = b
Theorem: Set.image2_iUnion_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [← image_prod, prod_iUnion, image_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.248318
ι₂ : Sort ?u.248321
κ : ι → Sort ?u.248326
κ₁ : ι → Sort ?u.248331
κ₂ : ι → Sort ?u.248336
κ' : ι' → Sort ?u.248341
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ image2 f s (⋃ (i : ι), t i) = ⋃ (i : ι), image2 f s (t i)
Theorem: Asymptotics.isLittleO_pow_id
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: convert isLittleO_pow_pow h (𝕜 := 𝕜)
state_before: α : Type ?u.647419
β : Type ?u.647422
E : Type ?u.647425
F : Type ?u.647428
G : Type ?u.647431
E' : Type ?u.647434
F' : Type ?u.647437
G' : Type ?u.647440
E'' : Type ?u.647443
F'' : Type ?u.647446
G'' : Type ?u.647449
R : Type ?u.647452
R' : Type ?u.647455
𝕜 : Type u_1
𝕜' : Type ?u.647461
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
n : ℕ
h : 1 < n
⊢ (fun x => x ^ n) =o[𝓝 0] fun x => x

tactic: simp only [pow_one]
state_before: case h.e'_8.h
α : Type ?u.647419
β : Type ?u.647422
E : Type ?u.647425
F : Type ?u.647428
G : Type ?u.647431
E' : Type ?u.647434
F' : Type ?u.647437
G' : Type ?u.647440
E'' : Type ?u.647443
F'' : Type ?u.647446
G'' : Type ?u.647449
R : Type ?u.647452
R' : Type ?u.647455
𝕜 : Type u_1
𝕜' : Type ?u.647461
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
n : ℕ
h : 1 < n
x✝ : 𝕜
⊢ x✝ = x✝ ^ 1
Theorem: nhdsWithin_Ioi_eq_bot_iff
File: Mathlib/Topology/Order/Basic.lean

tactic: by_cases ha : IsTop a
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
⊢ 𝓝[Ioi a] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b

tactic: simp [ha, ha.isMax.Ioi_eq]
state_before: case pos
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : IsTop a
⊢ 𝓝[Ioi a] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b

tactic: simp only [ha, false_or]
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ¬IsTop a
⊢ 𝓝[Ioi a] a = ⊥ ↔ IsTop a ∨ ∃ b, a ⋖ b

tactic: rw [isTop_iff_isMax, not_isMax_iff] at ha
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ¬IsTop a
⊢ 𝓝[Ioi a] a = ⊥ ↔ ∃ b, a ⋖ b

tactic: simp only [(nhdsWithin_Ioi_basis' ha).eq_bot_iff, covby_iff_Ioo_eq]
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ b, a < b
⊢ 𝓝[Ioi a] a = ⊥ ↔ ∃ b, a ⋖ b
Theorem: subset_balancedCore
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: rw [balancedCore_eq_iInter ht]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
⊢ s ⊆ balancedCore 𝕜 t

tactic: refine' subset_iInter₂ fun a ha => _
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
⊢ s ⊆ ⋂ (r : 𝕜) (_ : 1 ≤ ‖r‖), r • t

tactic: rw [← smul_inv_smul₀ (norm_pos_iff.mp <| zero_lt_one.trans_le ha) s]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ s ⊆ a • t

tactic: refine' smul_set_mono (hst _ _)
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ a • a⁻¹ • s ⊆ a • t

tactic: rw [norm_inv]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a⁻¹‖ ≤ 1

tactic: exact inv_le_one ha
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.73858
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
ht : 0 ∈ t
hst : ∀ (a : 𝕜), ‖a‖ ≤ 1 → a • s ⊆ t
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ ‖a‖⁻¹ ≤ 1
Theorem: PSigma.eta
File: src/lean/Init/Core.lean

tactic: subst h₁
state_before: a b c d : Prop
α : Sort u
β : α → Sort v
a₁ a₂ : α
b₁ : β a₁
b₂ : β a₂
h₁ : a₁ = a₂
h₂ : Eq.ndrec b₁ h₁ = b₂
⊢ { fst := a₁, snd := b₁ } = { fst := a₂, snd := b₂ }

tactic: subst h₂
state_before: a b c d : Prop
α : Sort u
β : α → Sort v
a₁ : α
b₁ b₂ : β a₁
h₂ : Eq.ndrec b₁ (_ : a₁ = a₁) = b₂
⊢ { fst := a₁, snd := b₁ } = { fst := a₁, snd := b₂ }

tactic: exact rfl
state_before: a b c d : Prop
α : Sort u
β : α → Sort v
a₁ : α
b₁ : β a₁
⊢ { fst := a₁, snd := b₁ } = { fst := a₁, snd := Eq.ndrec b₁ (_ : a₁ = a₁) }
Theorem: Fin.castLE_castLE
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [coe_castLE]
state_before: n✝ m✝ k m n : ℕ
km : k ≤ m
mn : m ≤ n
i : Fin k
⊢ ↑(↑(castLE mn) (↑(castLE km) i)) = ↑(↑(castLE (_ : k ≤ n)) i)
Theorem: MeasureTheory.measure_biUnion_finset_le
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: rw [← Finset.sum_attach, Finset.attach_eq_univ, ← tsum_fintype]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17750
δ : Type ?u.17753
ι : Type ?u.17756
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Finset β
f : β → Set α
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) ≤ ∑ p in s, ↑↑μ (f p)

tactic: exact measure_biUnion_le s.countable_toSet f
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17750
δ : Type ?u.17753
ι : Type ?u.17756
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Finset β
f : β → Set α
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) ≤ ∑' (b : { x // x ∈ s }), ↑↑μ (f ↑b)
Theorem: Finsupp.cons_zero_zero
File: Mathlib/Data/Finsupp/Fin.lean

tactic: ext a
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
⊢ cons 0 0 = 0

tactic: by_cases c : a = 0
state_before: case h
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
⊢ ↑(cons 0 0) a = ↑0 a

tactic: simp [c]
state_before: case pos
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c : a = 0
⊢ ↑(cons 0 0) a = ↑0 a

tactic: rw [← Fin.succ_pred a c, cons_succ]
state_before: case neg
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c : ¬a = 0
⊢ ↑(cons 0 0) a = ↑0 a

tactic: simp
state_before: case neg
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c : ¬a = 0
⊢ ↑0 (Fin.pred a c) = ↑0 (Fin.succ (Fin.pred a c))
Theorem: Int.mul_div_assoc
File: Std/Data/Int/DivMod.lean

tactic: simp [cz, Int.mul_zero]
state_before: a c d : Int
cz : c = 0
⊢ div (a * (c * d)) c = a * div (c * d) c

tactic: rw [Int.mul_left_comm, Int.mul_div_cancel_left _ cz, Int.mul_div_cancel_left _ cz]
state_before: a c d : Int
cz : ¬c = 0
⊢ div (a * (c * d)) c = a * div (c * d) c
Theorem: Fin.lt_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [castSucc, lt_iff_val_lt_val, coe_castAdd, val_succ]
state_before: n m : ℕ
a : Fin n
⊢ ↑castSucc a < succ a

tactic: exact lt_add_one a.val
state_before: n m : ℕ
a : Fin n
⊢ ↑a < ↑a + 1
Theorem: IsHilbertSum.linearIsometryEquiv_symm_apply
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simp [IsHilbertSum.linearIsometryEquiv, OrthogonalFamily.linearIsometry_apply]
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
hV : IsHilbertSum 𝕜 G V
w : { x // x ∈ lp G 2 }
⊢ ↑(LinearIsometryEquiv.symm (linearIsometryEquiv hV)) w = ∑' (i : ι), ↑(V i) (↑w i)
Theorem: Trivialization.coe_linearMapAt_of_mem
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: simp_rw [coe_linearMapAt, if_pos hb]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁸ : Semiring R
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalSpace B
inst✝⁵ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
⊢ ↑(Trivialization.linearMapAt R e b) = fun y => (↑e (totalSpaceMk b y)).snd
Theorem: Dfinsupp.card_Iic
File: Mathlib/Data/Dfinsupp/Interval.lean

tactic: simp_rw [Iic_eq_Icc, card_Icc, Dfinsupp.bot_eq_zero, support_zero, empty_union, zero_apply,
  bot_eq_zero]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → CanonicallyOrderedAddMonoid (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f : Π₀ (i : ι), α i
⊢ card (Iic f) = ∏ i in support f, card (Iic (↑f i))
Theorem: dist_prod_same_right
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [Prod.dist_eq, dist_nonneg]
state_before: α : Type u
β : Type v
X : Type ?u.246243
ι : Type ?u.246246
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
x₁ x₂ : α
y : β
⊢ dist (x₁, y) (x₂, y) = dist x₁ x₂
Theorem: hasFDerivWithinAt_of_not_mem_closure
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp only [mem_closure_iff_nhdsWithin_neBot, neBot_iff, Ne.def, Classical.not_not] at h
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.284702
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.284797
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬x ∈ closure s
⊢ HasFDerivWithinAt f f' s x

tactic: simp [HasFDerivWithinAt, HasFDerivAtFilter, h, IsLittleO, IsBigOWith]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.284702
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.284797
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : 𝓝[s] x = ⊥
⊢ HasFDerivWithinAt f f' s x
Theorem: Real.tendsto_exp_comp_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp_rw [←comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto f l atBot