tasksource/leandojo huggingface dataset:
Theorem: Cardinal.prod_eq_two_power
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← lift_id'.{u, v} (prod.{u, v} c), lift_prod, ← lift_two_power]
state_before: ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ prod c = 2 ^ lift (#ι)

tactic: apply le_antisymm
state_before: ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ (prod fun i => lift (c i)) = lift (2 ^ (#ι))

tactic: refine' (prod_le_prod _ _ h₂).trans_eq _
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ (prod fun i => lift (c i)) ≤ lift (2 ^ (#ι))

tactic: rw [prod_const, lift_lift, ← lift_power, power_self_eq (aleph0_le_mk ι), lift_umax.{u, v}]
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ (prod fun i => lift (#ι)) = lift (2 ^ (#ι))

tactic: rw [← prod_const', lift_prod]
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ lift (2 ^ (#ι)) ≤ prod fun i => lift (c i)

tactic: refine' prod_le_prod _ _ fun i => _
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
⊢ (prod fun i => lift 2) ≤ prod fun i => lift (c i)

tactic: rw [lift_two, ← lift_two.{u, v}, lift_le]
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
i : ι
⊢ lift 2 ≤ lift (c i)

tactic: exact h₁ i
state_before: case a
ι : Type u
inst✝ : Infinite ι
c : ι → Cardinal
h₁ : ∀ (i : ι), 2 ≤ c i
h₂ : ∀ (i : ι), lift (c i) ≤ lift (#ι)
i : ι
⊢ 2 ≤ c i
Theorem: StieltjesFunction.length_empty
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: simp
state_before: f : StieltjesFunction
⊢ (⨅ (_ : ∅ ⊆ Ioc 0 0), ofReal (↑f 0 - ↑f 0)) ≤ 0
Theorem: HasSum.div_const
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simp only [div_eq_mul_inv, h.mul_right b⁻¹]
state_before: ι : Type u_2
κ : Type ?u.6715
R : Type ?u.6718
α : Type u_1
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : HasSum f a
b : α
⊢ HasSum (fun i => f i / b) (a / b)
Theorem: Finset.piecewise_coe
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.295060
γ : Type ?u.295063
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : (j : α) → Decidable (j ∈ ↑s)
⊢ Set.piecewise (↑s) f g = piecewise s f g

tactic: congr
state_before: case h
α : Type u_1
β : Type ?u.295060
γ : Type ?u.295063
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : (j : α) → Decidable (j ∈ ↑s)
x✝ : α
⊢ Set.piecewise (↑s) f g x✝ = piecewise s f g x✝
Theorem: nilpotencyClass_eq_quotient_center_plus_one
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [nilpotencyClass_quotient_center]
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
⊢ nilpotencyClass G = nilpotencyClass (G ⧸ center G) + 1

tactic: rcases h : Group.nilpotencyClass G with ⟨⟩
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
⊢ nilpotencyClass G = nilpotencyClass G - 1 + 1

tactic: exfalso
state_before: case zero
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
h : nilpotencyClass G = Nat.zero
⊢ Nat.zero = Nat.zero - 1 + 1

tactic: rw [nilpotencyClass_zero_iff_subsingleton] at h
state_before: case zero.h
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
h : nilpotencyClass G = Nat.zero
⊢ False

tactic: skip
state_before: case zero.h
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
h : Subsingleton G
⊢ False

tactic: apply false_of_nontrivial_of_subsingleton G
state_before: case zero.h
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
h : Subsingleton G
⊢ False

tactic: simp
state_before: case succ
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : Normal H
hH : Group.IsNilpotent G
inst✝ : Nontrivial G
n✝ : ℕ
h : nilpotencyClass G = Nat.succ n✝
⊢ Nat.succ n✝ = Nat.succ n✝ - 1 + 1
Theorem: MeasureTheory.map_withDensity_abs_det_fderiv_eq_addHaar
File: Mathlib/MeasureTheory/Function/Jacobian.lean

tactic: apply Measure.ext fun t ht => ?_
state_before: E : Type u_1
F : Type ?u.847296
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : IsAddHaarMeasure μ
hs : MeasurableSet s
hf' : ∀ (x : E), x ∈ s → HasFDerivWithinAt f (f' x) s x
hf : InjOn f s
h'f : Measurable f
⊢ Measure.map f (withDensity (Measure.restrict μ s) fun x => ENNReal.ofReal (abs (ContinuousLinearMap.det (f' x)))) =
    Measure.restrict μ (f '' s)

tactic: rw [map_apply h'f ht, withDensity_apply _ (h'f ht), Measure.restrict_apply ht,
  restrict_restrict (h'f ht),
  lintegral_abs_det_fderiv_eq_addHaar_image μ ((h'f ht).inter hs)
    (fun x hx => (hf' x hx.2).mono (inter_subset_right _ _)) (hf.mono (inter_subset_right _ _)),
  image_preimage_inter]
state_before: E : Type u_1
F : Type ?u.847296
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s : Set E
f : E → E
f' : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : IsAddHaarMeasure μ
hs : MeasurableSet s
hf' : ∀ (x : E), x ∈ s → HasFDerivWithinAt f (f' x) s x
hf : InjOn f s
h'f : Measurable f
t : Set E
ht : MeasurableSet t
⊢ ↑↑(Measure.map f (withDensity (Measure.restrict μ s) fun x => ENNReal.ofReal (abs (ContinuousLinearMap.det (f' x)))))
      t =
    ↑↑(Measure.restrict μ (f '' s)) t
Theorem: RingQuot.sub_quot
File: Mathlib/Algebra/RingQuot.lean

tactic: show sub r _ _ = _
state_before: R✝ : Type u₁
inst✝⁴ : Semiring R✝
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type u₁
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ { toQuot := Quot.mk (Rel r) a } - { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a - b) }

tactic: rw [sub_def]
state_before: R✝ : Type u₁
inst✝⁴ : Semiring R✝
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type u₁
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ RingQuot.sub r { toQuot := Quot.mk (Rel r) a } { toQuot := Quot.mk (Rel r) b } = { toQuot := Quot.mk (Rel r) (a - b) }

tactic: rfl
state_before: R✝ : Type u₁
inst✝⁴ : Semiring R✝
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R✝ → R✝ → Prop
R : Type u₁
inst✝ : Ring R
r : R → R → Prop
a b : R
⊢ (match { toQuot := Quot.mk (Rel r) a }, { toQuot := Quot.mk (Rel r) b } with
    | { toQuot := a }, { toQuot := b } =>
      {
        toQuot :=
          Quot.map₂ Sub.sub (_ : ∀ ⦃a b c : R⦄, Rel r b c → Rel r (a - b) (a - c))
            (_ : ∀ ⦃a b c : R⦄, Rel r a b → Rel r (a - c) (b - c)) a b }) =
    { toQuot := Quot.mk (Rel r) (a - b) }
Theorem: Finset.inter_right_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_right_comm]
state_before: α : Type u_1
β : Type ?u.182360
γ : Type ?u.182363
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ∩ s₃ ↔ x✝ ∈ s₁ ∩ s₃ ∩ s₂
Theorem: LocalHomeomorph.nhds_eq_comap_inf_principal
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: lift x to e.source using hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.106516
δ : Type ?u.106519
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
x : α
hx : x ∈ e.source
⊢ 𝓝 x = comap (↑e) (𝓝 (↑e x)) ⊓ 𝓟 e.source

tactic: rw [← e.open_source.nhdsWithin_eq x.2, ← map_nhds_subtype_val, ← map_comap_setCoe_val,
  e.toHomeomorphSourceTarget.nhds_eq_comap, nhds_subtype_eq_comap]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.106516
δ : Type ?u.106519
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
x : { x // x ∈ e.source }
⊢ 𝓝 ↑x = comap (↑e) (𝓝 (↑e ↑x)) ⊓ 𝓟 e.source
Theorem: mul_eq_of_eq_div'
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.67616
β : Type ?u.67619
G : Type u_1
inst✝ : CommGroup G
a b c d : G
h : b = c / a
⊢ a * b = c

tactic: rw [mul_comm c, mul_inv_cancel_left]
state_before: α : Type ?u.67616
β : Type ?u.67619
G : Type u_1
inst✝ : CommGroup G
a b c d : G
h : b = c / a
⊢ a * (c * a⁻¹) = c
Theorem: CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp [← h, he]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ e ≫ g = 0

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ kernel.lift f e he ≫ (kernelIsoOfEq h).hom = kernel.lift g e (_ : e ≫ g = 0)

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasKernel f
e : Z ⟶ X
he : e ≫ f = 0
inst✝ : HasKernel f
⊢ kernel.lift f e he ≫ (kernelIsoOfEq (_ : f = f)).hom = kernel.lift f e (_ : e ≫ f = 0)
Theorem: LieSubmodule.monotone_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: intro N₁ N₂ h m hm
state_before: R : Type u_2
L : Type u_3
M : Type u_1
M' : Type ?u.16528
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
⊢ Monotone normalizer

tactic: rw [mem_normalizer] at hm ⊢
state_before: R : Type u_2
L : Type u_3
M : Type u_1
M' : Type ?u.16528
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁✝ N₂✝ N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
m : M
hm : m ∈ normalizer N₁
⊢ m ∈ normalizer N₂

tactic: exact fun x => h (hm x)
state_before: R : Type u_2
L : Type u_3
M : Type u_1
M' : Type ?u.16528
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁✝ N₂✝ N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
m : M
hm : ∀ (x : L), ⁅x, m⁆ ∈ N₁
⊢ ∀ (x : L), ⁅x, m⁆ ∈ N₂
Theorem: PEquiv.symm_trans_self
File: Mathlib/Data/PEquiv.lean

tactic: simp [symm_trans_rev, self_trans_symm, -symm_symm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ PEquiv.symm (PEquiv.trans (PEquiv.symm f) f) = PEquiv.symm (ofSet {b | isSome (↑(PEquiv.symm f) b) = true})
Theorem: Int.coprime_of_sq_sum
File: Mathlib/NumberTheory/Fermat4.lean

tactic: rw [sq, sq]
state_before: r s : ℤ
h2 : IsCoprime s r
⊢ IsCoprime (r ^ 2 + s ^ 2) r

tactic: exact (IsCoprime.mul_left h2 h2).mul_add_left_left r
state_before: r s : ℤ
h2 : IsCoprime s r
⊢ IsCoprime (r * r + s * s) r
Theorem: Finset.orderEmbOfFin_eq_orderEmbOfFin_iff
File: Mathlib/Data/Finset/Sort.lean

tactic: substs k l
state_before: α : Type u_1
β : Type ?u.57513
inst✝ : LinearOrder α
k l : ℕ
s : Finset α
i : Fin k
j : Fin l
h : card s = k
h' : card s = l
⊢ ↑(orderEmbOfFin s h) i = ↑(orderEmbOfFin s h') j ↔ ↑i = ↑j

tactic: exact (s.orderEmbOfFin rfl).eq_iff_eq.trans Fin.ext_iff
state_before: α : Type u_1
β : Type ?u.57513
inst✝ : LinearOrder α
s : Finset α
i j : Fin (card s)
⊢ ↑(orderEmbOfFin s (_ : card s = card s)) i = ↑(orderEmbOfFin s (_ : card s = card s)) j ↔ ↑i = ↑j
Theorem: OrderIso.map_sSup
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [sSup_eq_iSup, OrderIso.map_iSup]
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.81152
γ : Type ?u.81155
ι : Sort ?u.81158
ι' : Sort ?u.81161
κ : ι → Sort ?u.81166
κ' : ι' → Sort ?u.81171
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
f : α ≃o β
s : Set α
⊢ ↑f (sSup s) = ⨆ (a : α) (_ : a ∈ s), ↑f a
Theorem: Finset.map_ofDual_min
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [max_eq_sup_withBot, sup_image]
state_before: F : Type ?u.346509
α : Type u_1
β : Type ?u.346515
γ : Type ?u.346518
ι : Type ?u.346521
κ : Type ?u.346524
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
⊢ WithTop.map (↑ofDual) (Finset.min s) = Finset.max (image (↑ofDual) s)

tactic: exact congr_fun Option.map_id _
state_before: F : Type ?u.346509
α : Type u_1
β : Type ?u.346515
γ : Type ?u.346518
ι : Type ?u.346521
κ : Type ?u.346524
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
⊢ WithTop.map (↑ofDual) (Finset.min s) = sup s (WithBot.some ∘ ↑ofDual)
Theorem: disjoint_sdiff_comm
File: Mathlib/Order/BooleanAlgebra.lean

tactic: simp_rw [disjoint_iff, inf_sdiff_right_comm, inf_sdiff_assoc]
state_before: α : Type u
β : Type ?u.40724
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ Disjoint (x \ z) y ↔ Disjoint x (y \ z)
Theorem: ContinuousMap.isOpen_gen
File: Mathlib/Topology/CompactOpen.lean

tactic: dsimp [mem_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2117
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
s : Set α
hs : IsCompact s
u : Set β
hu : IsOpen u
⊢ CompactOpen.gen s u ∈ {m | ∃ s x u x, m = CompactOpen.gen s u}

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2117
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
s : Set α
hs : IsCompact s
u : Set β
hu : IsOpen u
⊢ ∃ s_1 x u_1 x, CompactOpen.gen s u = CompactOpen.gen s_1 u_1
Theorem: AddLECancellable.lt_tsub_iff_right_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine' ⟨fun h' => (add_le_of_le_tsub_right_of_le h h'.le).lt_of_ne _, hc.lt_tsub_of_add_lt_right⟩
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a < b - c ↔ a + c < b

tactic: rintro rfl
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
h' : a < b - c
⊢ a + c ≠ b

tactic: exact h'.ne' hc.add_tsub_cancel_right
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
hc : AddLECancellable c
h : c ≤ a + c
h' : a < a + c - c
⊢ False
Theorem: Vector.tendsto_cons
File: Mathlib/Topology/List.lean

tactic: rw [tendsto_subtype_rng, cons_val]
state_before: α : Type u_1
β : Type ?u.64741
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : Vector α n
⊢ Tendsto (fun p => p.fst ::ᵥ p.snd) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l))

tactic: exact tendsto_fst.cons (Tendsto.comp continuousAt_subtype_val tendsto_snd)
state_before: α : Type u_1
β : Type ?u.64741
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : Vector α n
⊢ Tendsto (fun x => ↑(x.fst ::ᵥ x.snd)) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: ↑l))
Theorem: Array.get?_swap
File: Std/Data/Array/Lemmas.lean

tactic: simp [swap_def, get?_set, ← getElem_fin_eq_data_get]
state_before: α : Type u_1
a : Array α
i j : Fin (size a)
k : Nat
⊢ (swap a i j)[k]? = if j.val = k then some a[i.val] else if i.val = k then some a[j.val] else a[k]?
Theorem: BoxIntegral.HasIntegral.add
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [HasIntegral, ← integralSum_add] using h.add h'
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : HasIntegral I l f vol y
h' : HasIntegral I l g vol y'
⊢ HasIntegral I l (f + g) vol (y + y')
Theorem: ShrinkingLemma.PartialRefinement.find_mem
File: Mathlib/Topology/ShrinkingLemma.lean

tactic: rw [find]
state_before: ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
⊢ find c ne i ∈ c

tactic: split_ifs with h
state_before: ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
⊢ (if hi : ∃ v, v ∈ c ∧ i ∈ v.carrier then Exists.choose hi else Set.Nonempty.some ne) ∈ c

tactic: exacts [h.choose_spec.1, ne.some_mem]
state_before: case inl
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ∃ v, v ∈ c ∧ i ∈ v.carrier
⊢ Exists.choose h ∈ c

case inr
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ¬∃ v, v ∈ c ∧ i ∈ v.carrier
⊢ Set.Nonempty.some ne ∈ c
Theorem: Summable.vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: letI : UniformSpace G := TopologicalAddGroup.toUniformSpace G
state_before: α : Type u_2
β : Type ?u.773378
γ : Type ?u.773381
δ : Type ?u.773384
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
⊢ ∃ s, ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e

tactic: letI : UniformAddGroup G := comm_topologicalAddGroup_is_uniform
state_before: α : Type u_2
β : Type ?u.773378
γ : Type ?u.773381
δ : Type ?u.773384
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
this : UniformSpace G := TopologicalAddGroup.toUniformSpace G
⊢ ∃ s, ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e

tactic: rcases hf with ⟨y, hy⟩
state_before: α : Type u_2
β : Type ?u.773378
γ : Type ?u.773381
δ : Type ?u.773384
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
this✝ : UniformSpace G := TopologicalAddGroup.toUniformSpace G
this : UniformAddGroup G := comm_topologicalAddGroup_is_uniform
⊢ ∃ s, ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e

tactic: exact cauchySeq_finset_iff_vanishing.1 hy.cauchySeq e he
state_before: case intro
α : Type u_2
β : Type ?u.773378
γ : Type ?u.773381
δ : Type ?u.773384
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
e : Set G
he : e ∈ 𝓝 0
this✝ : UniformSpace G := TopologicalAddGroup.toUniformSpace G
this : UniformAddGroup G := comm_topologicalAddGroup_is_uniform
y : G
hy : HasSum f y
⊢ ∃ s, ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e
Theorem: List.map_fst_zip
File: Mathlib/Data/List/Zip.lean

tactic: simp [succ_le_succ_iff] at h
state_before: α : Type u
β : Type u_1
γ : Type ?u.82177
δ : Type ?u.82180
ε : Type ?u.82183
head✝¹ : α
as : List α
head✝ : β
bs : List β
h : length (head✝¹ :: as) ≤ length (head✝ :: bs)
⊢ map Prod.fst (zip (head✝¹ :: as) (head✝ :: bs)) = head✝¹ :: as

tactic: change _ :: map Prod.fst (zip as bs) = _ :: as
state_before: α : Type u
β : Type u_1
γ : Type ?u.82177
δ : Type ?u.82180
ε : Type ?u.82183
head✝¹ : α
as : List α
head✝ : β
bs : List β
h : length as ≤ length bs
⊢ map Prod.fst (zip (head✝¹ :: as) (head✝ :: bs)) = head✝¹ :: as

tactic: rw [map_fst_zip as bs h]
state_before: α : Type u
β : Type u_1
γ : Type ?u.82177
δ : Type ?u.82180
ε : Type ?u.82183
head✝¹ : α
as : List α
head✝ : β
bs : List β
h : length as ≤ length bs
⊢ (head✝¹, head✝).fst :: map Prod.fst (zip as bs) = head✝¹ :: as

tactic: simp at h
state_before: α : Type u
β : Type u_1
γ : Type ?u.82177
δ : Type ?u.82180
ε : Type ?u.82183
a : α
as : List α
h : length (a :: as) ≤ length []
⊢ map Prod.fst (zip (a :: as) []) = a :: as
Theorem: MeasureTheory.Lp.nnnorm_le_mul_nnnorm_of_ae_le_mul
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp only [nnnorm_def]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.418576
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : ℝ≥0
f : { x // x ∈ Lp E p }
g : { x // x ∈ Lp F p }
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖₊ ≤ c * ‖↑↑g x‖₊
⊢ ‖f‖₊ ≤ c * ‖g‖₊

tactic: have := snorm_le_nnreal_smul_snorm_of_ae_le_mul h p
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.418576
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : ℝ≥0
f : { x // x ∈ Lp E p }
g : { x // x ∈ Lp F p }
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖₊ ≤ c * ‖↑↑g x‖₊
⊢ ENNReal.toNNReal (snorm (↑↑f) p μ) ≤ c * ENNReal.toNNReal (snorm (↑↑g) p μ)

tactic: rwa [← ENNReal.toNNReal_le_toNNReal, ENNReal.smul_def, smul_eq_mul, ENNReal.toNNReal_mul,
  ENNReal.toNNReal_coe] at this
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.418576
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : ℝ≥0
f : { x // x ∈ Lp E p }
g : { x // x ∈ Lp F p }
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖₊ ≤ c * ‖↑↑g x‖₊
this : snorm (fun x => ↑↑f x) p μ ≤ c • snorm (fun x => ↑↑g x) p μ
⊢ ENNReal.toNNReal (snorm (↑↑f) p μ) ≤ c * ENNReal.toNNReal (snorm (↑↑g) p μ)

tactic: exact (Lp.memℒp _).snorm_ne_top
state_before: case ha
α : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.418576
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : ℝ≥0
f : { x // x ∈ Lp E p }
g : { x // x ∈ Lp F p }
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖₊ ≤ c * ‖↑↑g x‖₊
this : snorm (fun x => ↑↑f x) p μ ≤ c • snorm (fun x => ↑↑g x) p μ
⊢ snorm (fun x => ↑↑f x) p μ ≠ ⊤

tactic: exact ENNReal.mul_ne_top ENNReal.coe_ne_top (Lp.memℒp _).snorm_ne_top
state_before: case hb
α : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.418576
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : ℝ≥0
f : { x // x ∈ Lp E p }
g : { x // x ∈ Lp F p }
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖₊ ≤ c * ‖↑↑g x‖₊
this : snorm (fun x => ↑↑f x) p μ ≤ c • snorm (fun x => ↑↑g x) p μ
⊢ c • snorm (fun x => ↑↑g x) p μ ≠ ⊤
Theorem: Dfinsupp.finite_support
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: classical!
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
f : Π₀ (i : ι), β i
⊢ Set.Finite {i | ↑f i ≠ 0}

tactic: exact Trunc.induction_on f.support' fun xs =>
      (Multiset.toFinset xs.1).finite_toSet.subset fun i H =>
        Multiset.mem_toFinset.2 ((xs.prop i).resolve_right H)
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
f : Π₀ (i : ι), β i
em✝ : (a : Prop) → Decidable a
⊢ Set.Finite {i | ↑f i ≠ 0}