1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: lowerBounds_closure
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: simp_rw [mem_lowerBounds_iff_subset_Ici, isClosed_Ici.closure_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : ClosedIciTopology α
f : β → α
a✝ b : α
s✝ s : Set α
a : α
⊢ a ∈ lowerBounds (closure s) ↔ a ∈ lowerBounds s
state_after: no goals
Theorem: Multiset.map_count_True_eq_filter_card
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [count_eq_card_filter_eq, filter_map, card_map, Function.id_comp,
  eq_true_eq_id, Function.comp_apply]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
p : α → Prop
inst✝ : DecidablePred p
⊢ count True (map p s) = card (filter p s)
state_after: no goals
Theorem: IsOfFinOrder.natCard_powers_le_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: classical
simpa [ha.powers_eq_image_range_orderOf, Finset.card_range, Nat.Iio_eq_range]
  using Finset.card_image_le (s := Finset.range (orderOf a))
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
ha : IsOfFinOrder a
⊢ Nat.card ↑↑(powers a) ≤ orderOf a
state_after: no goals

tactic: simpa [ha.powers_eq_image_range_orderOf, Finset.card_range, Nat.Iio_eq_range]
  using Finset.card_image_le (s := Finset.range (orderOf a))
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
ha : IsOfFinOrder a
⊢ Nat.card ↑↑(powers a) ≤ orderOf a
state_after: no goals
Theorem: ProbabilityTheory.stieltjesOfMeasurableRat_unit_prod
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

tactic: simp_rw [stieltjesOfMeasurableRat,IsMeasurableRatCDF.stieltjesFunction,
  ← IsMeasurableRatCDF.stieltjesFunctionAux_unit_prod a]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
⊢ stieltjesOfMeasurableRat (fun p => f p.2) ⋯ ((), a) = stieltjesOfMeasurableRat f hf a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
⊢ { toFun := IsMeasurableRatCDF.stieltjesFunctionAux (toRatCDF fun p => f p.2) ((), a), mono' := ⋯,
      right_continuous' := ⋯ } =
    { toFun := IsMeasurableRatCDF.stieltjesFunctionAux (fun p => toRatCDF f p.2) ((), a), mono' := ⋯,
      right_continuous' := ⋯ }

tactic: congr with x
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
⊢ { toFun := IsMeasurableRatCDF.stieltjesFunctionAux (toRatCDF fun p => f p.2) ((), a), mono' := ⋯,
      right_continuous' := ⋯ } =
    { toFun := IsMeasurableRatCDF.stieltjesFunctionAux (fun p => toRatCDF f p.2) ((), a), mono' := ⋯,
      right_continuous' := ⋯ }
state_after: case e_toFun.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
x : ℝ
⊢ IsMeasurableRatCDF.stieltjesFunctionAux (toRatCDF fun p => f p.2) ((), a) x =
    IsMeasurableRatCDF.stieltjesFunctionAux (fun p => toRatCDF f p.2) ((), a) x

tactic: congr 1 with p : 1
state_before: case e_toFun.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
x : ℝ
⊢ IsMeasurableRatCDF.stieltjesFunctionAux (toRatCDF fun p => f p.2) ((), a) x =
    IsMeasurableRatCDF.stieltjesFunctionAux (fun p => toRatCDF f p.2) ((), a) x
state_after: case e_toFun.h.e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
x : ℝ
p : Unit × α
⊢ toRatCDF (fun p => f p.2) p = toRatCDF f p.2

tactic: cases p with
| mk _ b => rw [← toRatCDF_unit_prod b]
state_before: case e_toFun.h.e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
x : ℝ
p : Unit × α
⊢ toRatCDF (fun p => f p.2) p = toRatCDF f p.2
state_after: no goals

tactic: rw [← toRatCDF_unit_prod b]
state_before: case e_toFun.h.e_f.h.mk
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : Measurable f
a : α
x : ℝ
fst✝ : Unit
b : α
⊢ toRatCDF (fun p => f p.2) (fst✝, b) = toRatCDF f (fst✝, b).2
state_after: no goals
Theorem: Finset.Ioc_subset_Ioi_self
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioi_self
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderTop α
⊢ Ioc a b ⊆ Ioi a
state_after: no goals
Theorem: List.max_le_of_forall_le
File: Mathlib/Data/List/MinMax.lean

tactic: induction' l with y l IH
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a : α
h : ∀ (x : α), x ∈ l → x ≤ a
⊢ foldr max ⊥ l ≤ a
state_after: case nil
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
a : α
h : ∀ (x : α), x ∈ [] → x ≤ a
⊢ foldr max ⊥ [] ≤ a

case cons
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a y : α
l : List α
IH : (∀ (x : α), x ∈ l → x ≤ a) → foldr max ⊥ l ≤ a
h : ∀ (x : α), x ∈ y :: l → x ≤ a
⊢ foldr max ⊥ (y :: l) ≤ a

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
a : α
h : ∀ (x : α), x ∈ [] → x ≤ a
⊢ foldr max ⊥ [] ≤ a
state_after: no goals

tactic: simpa [h y (mem_cons_self _ _)] using IH fun x hx => h x <| mem_cons_of_mem _ hx
state_before: case cons
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a y : α
l : List α
IH : (∀ (x : α), x ∈ l → x ≤ a) → foldr max ⊥ l ≤ a
h : ∀ (x : α), x ∈ y :: l → x ≤ a
⊢ foldr max ⊥ (y :: l) ≤ a
state_after: no goals
Theorem: TopCat.Presheaf.map_restrict
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: delta restrictOpen restrict
state_before: C✝ : Type u
inst✝² : Category.{v, u} C✝
X : TopCat
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : ConcreteCategory C
F G : Presheaf C X
e : F ⟶ G
U V : Opens ↑X
h : U ≤ V
x : (forget C).obj (F.obj { unop := V })
⊢ (e.app { unop := U }) ((x |_ U) h) = ((e.app { unop := V }) x |_ U) h
state_after: C✝ : Type u
inst✝² : Category.{v, u} C✝
X : TopCat
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : ConcreteCategory C
F G : Presheaf C X
e : F ⟶ G
U V : Opens ↑X
h : U ≤ V
x : (forget C).obj (F.obj { unop := V })
⊢ (e.app { unop := U }) ((F.map (homOfLE h).op) x) = (G.map (homOfLE h).op) ((e.app { unop := V }) x)

tactic: rw [← comp_apply, NatTrans.naturality, comp_apply]
state_before: C✝ : Type u
inst✝² : Category.{v, u} C✝
X : TopCat
C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : ConcreteCategory C
F G : Presheaf C X
e : F ⟶ G
U V : Opens ↑X
h : U ≤ V
x : (forget C).obj (F.obj { unop := V })
⊢ (e.app { unop := U }) ((F.map (homOfLE h).op) x) = (G.map (homOfLE h).op) ((e.app { unop := V }) x)
state_after: no goals
Theorem: iUnion_Ioc_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zero_add] using iUnion_Ioc_add_zsmul hp 0
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a : α
⊢ ⋃ n, Ioc (n • p) ((n + 1) • p) = univ
state_after: no goals
Theorem: Vector.mapAccumr₂_comm
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs, ys using Vector.inductionOn₂ generalizing s <;> simp_all
state_before: α : Type
n : ℕ
xs ys : Vector α n
σ γ : Type
s : σ
f : α → α → σ → σ × γ
comm : ∀ (a₁ a₂ : α) (s : σ), f a₁ a₂ s = f a₂ a₁ s
⊢ mapAccumr₂ f xs ys s = mapAccumr₂ f ys xs s
state_after: no goals
Theorem: Set.mul_zero_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [subset_def, mem_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : MulZeroClass α
s✝ t s : Set α
⊢ s * 0 ⊆ 0
state_after: no goals
Theorem: Set.mulIndicator_rel_mulIndicator
File: Mathlib/Algebra/Group/Indicator.lean

tactic: simp only [mulIndicator]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
⊢ r (s.mulIndicator f a) (s.mulIndicator g a)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
⊢ r (if a ∈ s then f a else 1) (if a ∈ s then g a else 1)

tactic: split_ifs with has
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
⊢ r (if a ∈ s then f a else 1) (if a ∈ s then g a else 1)
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
has : a ∈ s
⊢ r (f a) (g a)

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
has : a ∉ s
⊢ r 1 1

tactic: exacts [ha has, h1]
state_before: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
has : a ∈ s
⊢ r (f a) (g a)

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
r : M → M → Prop
h1 : r 1 1
ha : a ∈ s → r (f a) (g a)
has : a ∉ s
⊢ r 1 1
state_after: no goals
Theorem: DihedralGroup.sr_mul_self
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: rw [sr_mul_sr, sub_self, one_def]
state_before: n : ℕ
i : ZMod n
⊢ sr i * sr i = 1
state_after: no goals
Theorem: Nat.Subtype.coe_comp_ofNat_range
File: Mathlib/Logic/Denumerable.lean

tactic: rw [Set.range_comp Subtype.val, ofNat_range, Set.image_univ, Subtype.range_coe]
state_before: α : Type u_1
β : Type u_2
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
⊢ Set.range (Subtype.val ∘ ofNat s) = s
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.noSibling_tail
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ (tail le s).NoSibling
state_after: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ ((tail? le s).getD nil).NoSibling

tactic: match eq : s.tail? le with
| none => cases s with cases eq | nil => constructor
| some tl => exact Heap.noSibling_tail? eq
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ ((tail? le s).getD nil).NoSibling
state_after: no goals

tactic: cases s with cases eq | nil => constructor
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
eq : tail? le s = none
⊢ (none.getD nil).NoSibling
state_after: no goals

tactic: constructor
state_before: case nil.refl
α : Type u_1
le : α → α → Bool
⊢ (none.getD nil).NoSibling
state_after: no goals

tactic: exact Heap.noSibling_tail? eq
state_before: α : Type u_1
le : α → α → Bool
s tl : Heap α
eq : tail? le s = some tl
⊢ ((some tl).getD nil).NoSibling
state_after: no goals
Theorem: neg_vsub_eq_vsub_rev
File: Mathlib/Algebra/AddTorsor.lean

tactic: refine neg_eq_of_add_eq_zero_right (vadd_right_cancel p₁ ?_)
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ : P
⊢ -(p₁ -ᵥ p₂) = p₂ -ᵥ p₁
state_after: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ : P
⊢ p₁ -ᵥ p₂ + (p₂ -ᵥ p₁) +ᵥ p₁ = 0 +ᵥ p₁

tactic: rw [vsub_add_vsub_cancel, vsub_self]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ : P
⊢ p₁ -ᵥ p₂ + (p₂ -ᵥ p₁) +ᵥ p₁ = 0 +ᵥ p₁
state_after: no goals
Theorem: Set.mk_preimage_prod_right
File: Mathlib/Data/Set/Prod.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ha : a ∈ s
⊢ Prod.mk a ⁻¹' s ×ˢ t = t
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : a ∈ s
b : β
⊢ b ∈ Prod.mk a ⁻¹' s ×ˢ t ↔ b ∈ t

tactic: simp [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : a ∈ s
b : β
⊢ b ∈ Prod.mk a ⁻¹' s ×ˢ t ↔ b ∈ t
state_after: no goals
Theorem: CompleteLattice.Independent.dfinsupp_sumAddHom_injective
File: Mathlib/LinearAlgebra/DFinsupp.lean

tactic: rw [← independent_map_orderIso_iff (AddSubgroup.toIntSubmodule : AddSubgroup N ≃o _)] at h
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Ring R
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : ι → AddSubgroup N
h : Independent p
⊢ Function.Injective ⇑(sumAddHom fun i => (p i).subtype)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Ring R
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : ι → AddSubgroup N
h : Independent (⇑AddSubgroup.toIntSubmodule ∘ p)
⊢ Function.Injective ⇑(sumAddHom fun i => (p i).subtype)

tactic: exact h.dfinsupp_lsum_injective
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Ring R
inst✝¹ : AddCommGroup N
inst✝ : Module R N
p : ι → AddSubgroup N
h : Independent (⇑AddSubgroup.toIntSubmodule ∘ p)
⊢ Function.Injective ⇑(sumAddHom fun i => (p i).subtype)
state_after: no goals
Theorem: IsSelfAdjoint.conjugate
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_mul, star_star, mul_assoc, hx.star_eq]
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Semigroup R
inst✝ : StarMul R
x : R
hx : IsSelfAdjoint x
z : R
⊢ IsSelfAdjoint (z * x * star z)
state_after: no goals
Theorem: RatFunc.map_apply_ofFractionRing_mk
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: refine (liftOn_ofFractionRing_mk n _ _ _).trans ?_
state_before: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (map φ hφ) { toFractionRing := Localization.mk n d } = { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
state_after: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (if h : φ ↑d ∈ S[X]⁰ then { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, h⟩ } else 0) =
    { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }

tactic: rw [dif_pos]
state_before: K : Type u
inst✝⁶ : CommRing K
G₀ : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝⁵ : CommGroupWithZero G₀
inst✝⁴ : Field L
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : MonoidHomClass F R[X] S[X]
φ : F
hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰
n : R[X]
d : ↥R[X]⁰
⊢ (if h : φ ↑d ∈ S[X]⁰ then { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, h⟩ } else 0) =
    { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
state_after: no goals
Theorem: smul_floorDiv
File: Mathlib/Algebra/Order/Floor/Div.lean

tactic: simp [smul_le_smul_iff_of_pos_left, ha]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : OrderedSemiring α
inst✝⁴ : OrderedAddCommMonoid β
inst✝³ : MulActionWithZero α β
inst✝² : FloorDiv α β
a : α
inst✝¹ : PosSMulMono α β
inst✝ : PosSMulReflectLE α β
ha : 0 < a
b : β
⊢ ∀ (c : β), c ≤ a • b ⌊/⌋ a ↔ c ≤ b
state_after: no goals
Theorem: intrinsicInterior_empty
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: simp [intrinsicInterior]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
⊢ intrinsicInterior 𝕜 ∅ = ∅
state_after: no goals
Theorem: Real.logb_prod
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: induction' s using Finset.induction_on with a s ha ih
state_before: b x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ x ∈ s, f x ≠ 0
⊢ logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i)
state_after: case empty
b x y : ℝ
α : Type u_1
f : α → ℝ
hf : ∀ x ∈ ∅, f x ≠ 0
⊢ logb b (∏ i ∈ ∅, f i) = ∑ i ∈ ∅, logb b (f i)

case insert
b x y : ℝ
α : Type u_1
f : α → ℝ
a : α
s : Finset α
ha : a ∉ s
ih : (∀ x ∈ s, f x ≠ 0) → logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i)
hf : ∀ x ∈ insert a s, f x ≠ 0
⊢ logb b (∏ i ∈ insert a s, f i) = ∑ i ∈ insert a s, logb b (f i)

tactic: simp only [Finset.mem_insert, forall_eq_or_imp] at hf
state_before: case insert
b x y : ℝ
α : Type u_1
f : α → ℝ
a : α
s : Finset α
ha : a ∉ s
ih : (∀ x ∈ s, f x ≠ 0) → logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i)
hf : ∀ x ∈ insert a s, f x ≠ 0
⊢ logb b (∏ i ∈ insert a s, f i) = ∑ i ∈ insert a s, logb b (f i)
state_after: case insert
b x y : ℝ
α : Type u_1
f : α → ℝ
a : α
s : Finset α
ha : a ∉ s
ih : (∀ x ∈ s, f x ≠ 0) → logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i)
hf : f a ≠ 0 ∧ ∀ a ∈ s, f a ≠ 0
⊢ logb b (∏ i ∈ insert a s, f i) = ∑ i ∈ insert a s, logb b (f i)

tactic: simp [ha, ih hf.2, logb_mul hf.1 (Finset.prod_ne_zero_iff.2 hf.2)]
state_before: case insert
b x y : ℝ
α : Type u_1
f : α → ℝ
a : α
s : Finset α
ha : a ∉ s
ih : (∀ x ∈ s, f x ≠ 0) → logb b (∏ i ∈ s, f i) = ∑ i ∈ s, logb b (f i)
hf : f a ≠ 0 ∧ ∀ a ∈ s, f a ≠ 0
⊢ logb b (∏ i ∈ insert a s, f i) = ∑ i ∈ insert a s, logb b (f i)
state_after: no goals

tactic: simp
state_before: case empty
b x y : ℝ
α : Type u_1
f : α → ℝ
hf : ∀ x ∈ ∅, f x ≠ 0
⊢ logb b (∏ i ∈ ∅, f i) = ∑ i ∈ ∅, logb b (f i)
state_after: no goals
Theorem: div_mul_cancel_left
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div, mul_div_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a✝ b✝ c d a b : G
⊢ a / (a * b) = b⁻¹
state_after: no goals
Theorem: String.extract.go₁_append_right
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: cases t <;> simp [go₁, go₂]
state_before: t : List Char
i : Nat
e : Pos
⊢ go₁ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } e = go₂ t { byteIdx := utf8Len [] + i } e
state_after: no goals

tactic: simp only [go₁, utf8Len_cons, Pos.ext_iff, ne_add_csize_add_self, ↓reduceIte, List.append_eq,
  Pos.addChar_eq]
state_before: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } e =
    go₂ t { byteIdx := utf8Len (c :: cs) + i } e
state_after: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } e =
    go₂ t { byteIdx := utf8Len cs + c.utf8Size + i } e

tactic: apply go₁_append_right
state_before: c : Char
cs t : List Char
i : Nat
e : Pos
⊢ go₁ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } e =
    go₂ t { byteIdx := utf8Len cs + c.utf8Size + i } e
state_after: case a
c : Char
cs t : List Char
i : Nat
e : Pos
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)

tactic: rw [Nat.add_right_comm, Nat.add_assoc]
state_before: case a
c : Char
cs t : List Char
i : Nat
e : Pos
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
state_after: no goals
Theorem: equicontinuousAt_finite
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp [EquicontinuousAt, ContinuousAt, (nhds_basis_uniformity' (𝓤 α).basis_sets).tendsto_right_iff,
  UniformSpace.ball, @forall_swap _ ι]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
inst✝ : Finite ι
F : ι → X → α
x₀ : X
⊢ EquicontinuousAt F x₀ ↔ ∀ (i : ι), ContinuousAt (F i) x₀
state_after: no goals
Theorem: CategoryTheory.Adjunction.homEquiv_leftAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: simp [leftAdjointUniq]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ (adj1.homEquiv x (F'.obj x)) ((adj1.leftAdjointUniq adj2).hom.app x) = adj2.unit.app x
state_after: no goals
Theorem: PiLp.norm_sq_eq_of_L2
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: suffices ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2 by
  simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2

tactic: rw [nnnorm_eq_of_L2, NNReal.sq_sqrt]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2
state_after: no goals

tactic: simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
this : ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2
⊢ ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2
state_after: no goals
Theorem: DFinsupp.erase_add
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp [ite_zero_add]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f₁ f₂ : Π₀ (i : ι), β i
x✝ : ι
⊢ (erase i (f₁ + f₂)) x✝ = (erase i f₁ + erase i f₂) x✝
state_after: no goals
Theorem: LocallyFinite.eventually_subset
File: Mathlib/Topology/LocallyFinite.lean

tactic: filter_upwards [hs.iInter_compl_mem_nhds hs' x] with y hy i hi
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g s : ι → Set X
hs : LocallyFinite s
hs' : ∀ (i : ι), IsClosed (s i)
x : X
⊢ ∀ᶠ (y : X) in 𝓝 x, {i | y ∈ s i} ⊆ {i | x ∈ s i}
state_after: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g s : ι → Set X
hs : LocallyFinite s
hs' : ∀ (i : ι), IsClosed (s i)
x y : X
hy : y ∈ ⋂ i, ⋂ (_ : x ∉ s i), (s i)ᶜ
i : ι
hi : i ∈ {i | y ∈ s i}
⊢ i ∈ {i | x ∈ s i}

tactic: simp only [mem_iInter, mem_compl_iff] at hy
state_before: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g s : ι → Set X
hs : LocallyFinite s
hs' : ∀ (i : ι), IsClosed (s i)
x y : X
hy : y ∈ ⋂ i, ⋂ (_ : x ∉ s i), (s i)ᶜ
i : ι
hi : i ∈ {i | y ∈ s i}
⊢ i ∈ {i | x ∈ s i}
state_after: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g s : ι → Set X
hs : LocallyFinite s
hs' : ∀ (i : ι), IsClosed (s i)
x y : X
i : ι
hi : i ∈ {i | y ∈ s i}
hy : ∀ (i : ι), x ∉ s i → y ∉ s i
⊢ i ∈ {i | x ∈ s i}

tactic: exact not_imp_not.mp (hy i) hi
state_before: case h
ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g s : ι → Set X
hs : LocallyFinite s
hs' : ∀ (i : ι), IsClosed (s i)
x y : X
i : ι
hi : i ∈ {i | y ∈ s i}
hy : ∀ (i : ι), x ∉ s i → y ∉ s i
⊢ i ∈ {i | x ∈ s i}
state_after: no goals