tasksource/leandojo huggingface dataset:
Theorem: Set.Iic_diff_Iio
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [diff_eq, compl_Iio, inter_comm, Ici_inter_Iic]
state_before: α : Type u_1
β : Type ?u.63193
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Iic b \ Iio a = Icc a b
Theorem: Associates.count_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: induction' k with n h
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
k : ℕ
⊢ count p (factors (a ^ k)) = k * count p (factors a)

tactic: rw [pow_zero, factors_one, Nat.zero_eq, zero_mul, count_zero hp]
state_before: case zero
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
⊢ count p (factors (a ^ Nat.zero)) = Nat.zero * count p (factors a)

tactic: rw [pow_succ, count_mul ha (pow_ne_zero _ ha) hp, h, Nat.succ_eq_add_one]
state_before: case succ
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
n : ℕ
h : count p (factors (a ^ n)) = n * count p (factors a)
⊢ count p (factors (a ^ Nat.succ n)) = Nat.succ n * count p (factors a)

tactic: ring
state_before: case succ
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
n : ℕ
h : count p (factors (a ^ n)) = n * count p (factors a)
⊢ count p (factors a) + n * count p (factors a) = (n + 1) * count p (factors a)
Theorem: Filter.liminf_compl
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsup_eq_iInf_iSup, compl_iInf, compl_iSup, liminf_eq_iSup_iInf, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.171159
ι : Type ?u.171162
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
⊢ liminf u fᶜ = limsup (compl ∘ u) f
Theorem: Stream'.WSeq.toSeq_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ toSeq ↑s = s

tactic: funext n
state_before: case a
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ↑(toSeq ↑s) = ↑s

tactic: dsimp [toSeq]
state_before: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑(toSeq ↑s) n = ↑s n

tactic: apply get_eq_of_mem
state_before: case a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ Computation.get (get? (↑s) n) = ↑s n

tactic: rw [get?_ofSeq]
state_before: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ get? (↑s) n

tactic: apply ret_mem
state_before: case a.h.a
α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ↑s n ∈ Computation.pure (Seq.get? s n)
Theorem: StrictConcaveOn.secant_strict_mono
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have key := hf.neg.secant_strict_mono ha hx hy hxa hya hxy
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
⊢ (f y - f a) / (y - a) < (f x - f a) / (x - a)

tactic: simp only [Pi.neg_apply] at key
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
key : ((-f) x - (-f) a) / (x - a) < ((-f) y - (-f) a) / (y - a)
⊢ (f y - f a) / (y - a) < (f x - f a) / (x - a)

tactic: rw [← neg_lt_neg_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
key : (-f x - -f a) / (x - a) < (-f y - -f a) / (y - a)
⊢ (f y - f a) / (y - a) < (f x - f a) / (x - a)

tactic: convert key using 1 <;> field_simp <;> ring
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
key : (-f x - -f a) / (x - a) < (-f y - -f a) / (y - a)
⊢ -((f x - f a) / (x - a)) < -((f y - f a) / (y - a))
Theorem: CategoryTheory.Subobject.ofLEMk_comp_ofMkLEMk
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ofMkLEMk, ← Functor.map_comp_assoc underlying,
  assoc, Iso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ ofLEMk X f h₁ ≫ ofMkLEMk f g h₂ = ofLEMk X g (_ : X ≤ mk g)

tactic: congr 1
state_before: C : Type u₁
inst✝³ : Category C
X✝ Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ underlying.map (LE.le.hom h₁ ≫ LE.le.hom h₂) ≫ (underlyingIso g).hom =
    underlying.map (LE.le.hom (_ : X ≤ mk g)) ≫ (underlyingIso g).hom
Theorem: Metric.mk_uniformity_basis
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: refine' ⟨fun s => uniformity_basis_dist.mem_iff.trans _⟩
state_before: α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
⊢ HasBasis (𝓤 α) p fun i => {p | dist p.fst p.snd < f i}

tactic: constructor
state_before: α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
s : Set (α × α)
⊢ (∃ i, 0 < i ∧ {p | dist p.fst p.snd < i} ⊆ s) ↔ ∃ i, p i ∧ {p | dist p.fst p.snd < f i} ⊆ s

tactic: rintro ⟨ε, ε₀, hε⟩
state_before: case mp
α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
s : Set (α × α)
⊢ (∃ i, 0 < i ∧ {p | dist p.fst p.snd < i} ⊆ s) → ∃ i, p i ∧ {p | dist p.fst p.snd < f i} ⊆ s

tactic: rcases hf ε₀ with ⟨i, hi, H⟩
state_before: case mp.intro.intro
α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
s : Set (α × α)
ε : ℝ
ε₀ : 0 < ε
hε : {p | dist p.fst p.snd < ε} ⊆ s
⊢ ∃ i, p i ∧ {p | dist p.fst p.snd < f i} ⊆ s

tactic: exact ⟨i, hi, fun x (hx : _ < _) => hε <| lt_of_lt_of_le hx H⟩
state_before: case mp.intro.intro.intro.intro
α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
s : Set (α × α)
ε : ℝ
ε₀ : 0 < ε
hε : {p | dist p.fst p.snd < ε} ⊆ s
i : β
hi : p i
H : f i ≤ ε
⊢ ∃ i, p i ∧ {p | dist p.fst p.snd < f i} ⊆ s

tactic: exact fun ⟨i, hi, H⟩ => ⟨f i, hf₀ i hi, H⟩
state_before: case mpr
α : Type u
β✝ : Type v
X : Type ?u.49504
ι : Type ?u.49507
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
β : Type u_1
p : β → Prop
f : β → ℝ
hf₀ : ∀ (i : β), p i → 0 < f i
hf : ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ i, p i ∧ f i ≤ ε
s : Set (α × α)
⊢ (∃ i, p i ∧ {p | dist p.fst p.snd < f i} ⊆ s) → ∃ i, 0 < i ∧ {p | dist p.fst p.snd < i} ⊆ s
Theorem: CategoryTheory.obj_zero_map_μ_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← IsIso.inv_comp_eq, ← IsIso.comp_inv_eq]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (F.obj (𝟙_ M)).map f ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m (𝟙_ M)).app Y =
    (MonoidalFunctor.εIso F).inv.app X ≫ f ≫ (F.map (ρ_ m).inv).app Y

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (inv ((MonoidalFunctor.εIso F).inv.app X) ≫
        (F.obj (𝟙_ M)).map f ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m (𝟙_ M)).app Y) ≫
      inv ((F.map (ρ_ m).inv).app Y) =
    f
Theorem: Relation.reflTransGen_iff_eq
File: Mathlib/Logic/Relation.lean

tactic: rw [cases_head_iff]
state_before: α : Type u_1
β : Type ?u.24015
γ : Type ?u.24018
δ : Type ?u.24021
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ ReflTransGen r a b ↔ b = a

tactic: simp [h, eq_comm]
state_before: α : Type u_1
β : Type ?u.24015
γ : Type ?u.24018
δ : Type ?u.24021
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) ↔ b = a
Theorem: CategoryTheory.LaxMonoidalFunctor.left_unitality_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: rw [Iso.inv_comp_eq, F.left_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp,
  Iso.hom_inv_id, F.toFunctor.map_id, comp_id]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (λ_ (F.obj X)).inv ≫ (F.ε ⊗ 𝟙 (F.obj X)) ≫ μ F (𝟙_ C) X = F.map (λ_ X).inv
Theorem: Function.minimalPeriod_eq_one_iff_isFixedPt
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ minimalPeriod f x = 1 ↔ IsFixedPt f x

tactic: rw [← iterate_one f]
state_before: case refine'_1
α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : minimalPeriod f x = 1
⊢ IsFixedPt f x

tactic: refine' Function.IsPeriodicPt.isFixedPt _
state_before: case refine'_1
α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : minimalPeriod f x = 1
⊢ IsFixedPt (f^[1]) x

tactic: rw [← h]
state_before: case refine'_1
α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : minimalPeriod f x = 1
⊢ IsPeriodicPt f 1 x

tactic: exact isPeriodicPt_minimalPeriod f x
state_before: case refine'_1
α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : minimalPeriod f x = 1
⊢ IsPeriodicPt f (minimalPeriod f x) x

tactic: exact
  ((h.isPeriodicPt 1).minimalPeriod_le Nat.one_pos).antisymm
    (Nat.succ_le_of_lt ((h.isPeriodicPt 1).minimalPeriod_pos Nat.one_pos))
state_before: case refine'_2
α : Type u_1
β : Type ?u.25081
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : IsFixedPt f x
⊢ minimalPeriod f x = 1
Theorem: List.filterMap_filter
File: Std/Data/List/Lemmas.lean

tactic: rw [← filterMap_eq_filter, filterMap_filterMap]
state_before: α : Type u_1
β : Type u_2
p : α → Bool
f : α → Option β
l : List α
⊢ filterMap f (filter p l) = filterMap (fun x => if p x = true then f x else none) l

tactic: congr
state_before: α : Type u_1
β : Type u_2
p : α → Bool
f : α → Option β
l : List α
⊢ filterMap (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) l =
    filterMap (fun x => if p x = true then f x else none) l

tactic: funext x
state_before: case e_f
α : Type u_1
β : Type u_2
p : α → Bool
f : α → Option β
l : List α
⊢ (fun x => Option.bind (Option.guard (fun x => p x = true) x) f) = fun x => if p x = true then f x else none

tactic: by_cases h : p x <;> simp [Option.guard, h]
state_before: case e_f.h
α : Type u_1
β : Type u_2
p : α → Bool
f : α → Option β
l : List α
x : α
⊢ Option.bind (Option.guard (fun x => p x = true) x) f = if p x = true then f x else none
Theorem: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyoneda
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: rw [isSeparator_iff_faithful_coyoneda_obj, ← whiskering_preadditiveCoyoneda, Functor.comp_obj,
  whiskeringRight_obj_obj]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
⊢ IsSeparator G ↔ Faithful (preadditiveCoyoneda.obj G.op)

tactic: exact ⟨fun h => Faithful.of_comp _ (forget AddCommGroupCat), fun h => Faithful.comp _ _⟩
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
⊢ Faithful (preadditiveCoyoneda.obj G.op ⋙ forget AddCommGroupCat) ↔ Faithful (preadditiveCoyoneda.obj G.op)
Theorem: Function.periodicOrbit_apply_iterate_eq
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply List.ext_nthLe _ fun m _ _ => _
state_before: α : Type u_1
β : Type ?u.32376
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ List.rotate (List.map (fun n => (f^[n]) x) (List.range (minimalPeriod f x))) n =
    List.map (fun n_1 => (f^[n_1]) ((f^[n]) x)) (List.range (minimalPeriod f ((f^[n]) x)))

tactic: simp [minimalPeriod_apply_iterate hx]
state_before: α : Type u_1
β : Type ?u.32376
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ List.length (List.rotate (List.map (fun n => (f^[n]) x) (List.range (minimalPeriod f x))) n) =
    List.length (List.map (fun n_1 => (f^[n_1]) ((f^[n]) x)) (List.range (minimalPeriod f ((f^[n]) x))))

tactic: simp [List.nthLe_rotate, iterate_add_apply]
state_before: α : Type u_1
β : Type ?u.32376
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ ∀ (m : ℕ) (x_1 : m < List.length (List.rotate (List.map (fun n => (f^[n]) x) (List.range (minimalPeriod f x))) n))
    (x_2 : m < List.length (List.map (fun n_1 => (f^[n_1]) ((f^[n]) x)) (List.range (minimalPeriod f ((f^[n]) x))))),
    List.nthLe (List.rotate (List.map (fun n => (f^[n]) x) (List.range (minimalPeriod f x))) n) m x_1 =
      List.nthLe (List.map (fun n_1 => (f^[n_1]) ((f^[n]) x)) (List.range (minimalPeriod f ((f^[n]) x)))) m x_2
Theorem: IsSubgroup.trivial_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: refine' { .. } <;> simp (config := { contextual := true }) [trivial]
state_before: G : Type u_1
H : Type ?u.28279
A : Type ?u.28282
a a₁ a₂ b c : G
inst✝ : Group G
⊢ IsNormalSubgroup (trivial G)
Theorem: Finset.prod_range_succ'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [prod_range_succ _ n, mul_right_comm, ← prod_range_succ' _ n, prod_range_succ]
state_before: ι : Type ?u.434314
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ k in range (n + 1 + 1), f k = (∏ k in range (n + 1), f (k + 1)) * f 0
Theorem: PFunctor.M.head_mk
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: rw [dest_mk]
state_before: F : PFunctor
X : Type ?u.26443
f : X → Obj F X
x : Obj F (M F)
⊢ x.fst = (dest (M.mk x)).fst

tactic: rfl
state_before: F : PFunctor
X : Type ?u.26443
f : X → Obj F X
x : Obj F (M F)
⊢ (dest (M.mk x)).fst = head (M.mk x)
Theorem: Set.ncard_diff
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [← ncard_diff_add_ncard_eq_ncard h ht, add_tsub_cancel_right]
state_before: α : Type u_1
β : Type ?u.124218
s t : Set α
a b x y : α
f : α → β
h : s ⊆ t
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard (t \ s) = ncard t - ncard s
Theorem: Multiset.Ioo_self
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ioo, Finset.Ioo_self, Finset.empty_val]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Ioo a a = 0
Theorem: MeasureTheory.Integrable.to_average
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rcases eq_or_ne μ 0 with (rfl | hne)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.851862
δ : Type ?u.851865
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
⊢ Integrable f

tactic: rwa [smul_zero]
state_before: case inl
α : Type u_2
β : Type u_1
γ : Type ?u.851862
δ : Type ?u.851865
m : MeasurableSpace α
ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
⊢ Integrable f

tactic: apply h.smul_measure
state_before: case inr
α : Type u_2
β : Type u_1
γ : Type ?u.851862
δ : Type ?u.851865
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
hne : μ ≠ 0
⊢ Integrable f

tactic: simpa
state_before: case inr
α : Type u_2
β : Type u_1
γ : Type ?u.851862
δ : Type ?u.851865
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f
hne : μ ≠ 0
⊢ (↑↑μ univ)⁻¹ ≠ ⊤
Theorem: ZFSet.choice_mem_aux
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rwa [← (eq_empty y).2 fun z zx => n ⟨z, zx⟩]
state_before: x : ZFSet
h : ¬∅ ∈ x
y : ZFSet
yx : y ∈ x
n : ¬∃ y_1, y_1 ∈ y
⊢ ∅ ∈ x
Theorem: IsPGroup.sylow_mem_fixedPoints_iff
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [P.sylow_mem_fixedPoints_iff, ← inf_eq_left, hP.inf_normalizer_sylow, inf_eq_left]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P : Subgroup G
hP : IsPGroup p { x // x ∈ P }
Q : Sylow p G
⊢ Q ∈ fixedPoints { x // x ∈ P } (Sylow p G) ↔ P ≤ ↑Q
Theorem: ConvexOn.exists_ge_of_mem_convexHull
File: Mathlib/Analysis/Convex/Jensen.lean

tactic: rw [_root_.convexHull_eq.{u, v, 0}] at hx
state_before: 𝕜 : Type u
E : Type v
F : Type ?u.65372
β : Type u_1
ι : Type ?u.65378
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
x✝ : E
hf : ConvexOn 𝕜 (↑(convexHull 𝕜).toOrderHom s) f
x : E
hx : x ∈ ↑(convexHull 𝕜).toOrderHom s
⊢ ∃ y, y ∈ s ∧ f x ≤ f y

tactic: obtain ⟨α, t, w, p, hw₀, hw₁, hp, rfl⟩ := hx
state_before: 𝕜 : Type u
E : Type v
F : Type ?u.65372
β : Type u_1
ι : Type ?u.65378
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
x✝ : E
hf : ConvexOn 𝕜 (↑(convexHull 𝕜).toOrderHom s) f
x : E
hx : x ∈ {x | ∃ ι t w z x_1 x_2 x_3, centerMass t w z = x}
⊢ ∃ y, y ∈ s ∧ f x ≤ f y

tactic: rcases hf.exists_ge_of_centerMass hw₀ (hw₁.symm ▸ zero_lt_one) fun i hi =>
    subset_convexHull 𝕜 s (hp i hi) with
  ⟨i, hit, Hi⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u
E : Type v
F : Type ?u.65372
β : Type u_1
ι : Type ?u.65378
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t✝ : Finset ι
w✝ : ι → 𝕜
p✝ : ι → E
x : E
hf : ConvexOn 𝕜 (↑(convexHull 𝕜).toOrderHom s) f
α : Type
t : Finset α
w : α → 𝕜
p : α → E
hw₀ : ∀ (i : α), i ∈ t → 0 ≤ w i
hw₁ : ∑ i in t, w i = 1
hp : ∀ (i : α), i ∈ t → p i ∈ s
⊢ ∃ y, y ∈ s ∧ f (centerMass t w p) ≤ f y

tactic: exact ⟨p i, hp i hit, Hi⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u
E : Type v
F : Type ?u.65372
β : Type u_1
ι : Type ?u.65378
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t✝ : Finset ι
w✝ : ι → 𝕜
p✝ : ι → E
x : E
hf : ConvexOn 𝕜 (↑(convexHull 𝕜).toOrderHom s) f
α : Type
t : Finset α
w : α → 𝕜
p : α → E
hw₀ : ∀ (i : α), i ∈ t → 0 ≤ w i
hw₁ : ∑ i in t, w i = 1
hp : ∀ (i : α), i ∈ t → p i ∈ s
i : α
hit : i ∈ t
Hi : f (centerMass t (fun i => w i) fun i => p i) ≤ f (p i)
⊢ ∃ y, y ∈ s ∧ f (centerMass t w p) ≤ f y
Theorem: SimpleGraph.Subgraph.coe_degree
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [← card_neighborSet_eq_degree]
state_before: ι : Sort ?u.202740
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : ↑G'.verts
inst✝¹ : Fintype ↑(SimpleGraph.neighborSet (Subgraph.coe G') v)
inst✝ : Fintype ↑(neighborSet G' ↑v)
⊢ SimpleGraph.degree (Subgraph.coe G') v = degree G' ↑v

tactic: exact Fintype.card_congr (coeNeighborSetEquiv v)
state_before: ι : Sort ?u.202740
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : ↑G'.verts
inst✝¹ : Fintype ↑(SimpleGraph.neighborSet (Subgraph.coe G') v)
inst✝ : Fintype ↑(neighborSet G' ↑v)
⊢ Fintype.card ↑(SimpleGraph.neighborSet (Subgraph.coe G') v) = degree G' ↑v
Theorem: ENNReal.rpow_le_rpow_of_exponent_le
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
y z : ℝ
hx : 1 ≤ x
hyz : y ≤ z
⊢ x ^ y ≤ x ^ z

tactic: rcases lt_trichotomy y 0 with (Hy | Hy | Hy) <;>
rcases lt_trichotomy z 0 with (Hz | Hz | Hz) <;>
simp [Hy, Hz, top_rpow_of_neg, top_rpow_of_pos, le_refl] <;>
linarith
state_before: case none
y z : ℝ
hyz : y ≤ z
hx : 1 ≤ none
⊢ none ^ y ≤ none ^ z

tactic: simp only [one_le_coe_iff, some_eq_coe] at hx
state_before: case some
y z : ℝ
hyz : y ≤ z
val✝ : ℝ≥0
hx : 1 ≤ Option.some val✝
⊢ Option.some val✝ ^ y ≤ Option.some val✝ ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt (lt_of_lt_of_le zero_lt_one hx)),
  NNReal.rpow_le_rpow_of_exponent_le hx hyz]
state_before: case some
y z : ℝ
hyz : y ≤ z
val✝ : ℝ≥0
hx : 1 ≤ val✝
⊢ Option.some val✝ ^ y ≤ Option.some val✝ ^ z
Theorem: exists_mem_Ioc_zpow
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rwa [zpow_neg, inv_lt (zpow_pos_of_pos hyp _) hx]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
m : ℤ
hle : y ^ m ≤ x⁻¹
hlt : x⁻¹ < y ^ (m + 1)
hyp : 0 < y
⊢ y ^ (-(m + 1)) < x

tactic: rwa [neg_add, neg_add_cancel_right, zpow_neg, le_inv hx (zpow_pos_of_pos hyp _)]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
m : ℤ
hle : y ^ m ≤ x⁻¹
hlt : x⁻¹ < y ^ (m + 1)
hyp : 0 < y
⊢ x ≤ y ^ (-(m + 1) + 1)
Theorem: MultilinearMap.uncurry_curryRight
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext m
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R M M₂
⊢ uncurryRight (curryRight f) = f

tactic: simp
state_before: case H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R M M₂
m : (i : Fin (Nat.succ n)) → M i
⊢ ↑(uncurryRight (curryRight f)) m = ↑f m
Theorem: orthogonalProjection_orthogonalProjection_of_le
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: simpa only [sub_eq_zero, map_sub] using
  orthogonalProjection_mem_subspace_orthogonalComplement_eq_zero
    (Submodule.orthogonal_le h (sub_orthogonalProjection_mem_orthogonal x))
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.841108
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K U V : Submodule 𝕜 E
inst✝¹ : CompleteSpace { x // x ∈ U }
inst✝ : CompleteSpace { x // x ∈ V }
h : U ≤ V
x : E
⊢ ↑(orthogonalProjection U) x = ↑(orthogonalProjection U) ↑(↑(orthogonalProjection V) x)