tasksource/leandojo huggingface dataset:
Theorem: Std.Range.mem_range'_elems
File: Std/Data/Range/Lemmas.lean

tactic: obtain ⟨i, h', rfl⟩ := List.mem_range'.1 h
state_before: x : Nat
r : Range
h : x ∈ List.range' r.start (numElems r) r.step
⊢ x ∈ r

tactic: refine ⟨Nat.le_add_right .., ?_⟩
state_before: case intro.intro
r : Range
i : Nat
h' : i < numElems r
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
⊢ r.start + r.step * i ∈ r

tactic: unfold numElems at h'
state_before: case intro.intro
r : Range
i : Nat
h' : i < numElems r
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
⊢ r.start + r.step * i < r.stop

tactic: split at h'
state_before: case intro.intro
r : Range
i : Nat
h' : i < if r.step = 0 then if r.stop ≤ r.start then 0 else r.stop else (r.stop - r.start + r.step - 1) / r.step
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
⊢ r.start + r.step * i < r.stop

tactic: split at h' <;> [cases h'; simp_all]
state_before: case intro.intro.inl
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
h✝ : r.step = 0
h' : i < if r.stop ≤ r.start then 0 else r.stop
⊢ r.start + r.step * i < r.stop

tactic: next step0 =>
refine Nat.not_le.1 fun h =>
  Nat.not_le.2 h' <| (numElems_le_iff (Nat.pos_of_ne_zero step0)).2 h
state_before: case intro.intro.inr
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
h✝ : ¬r.step = 0
h' : i < (r.stop - r.start + r.step - 1) / r.step
⊢ r.start + r.step * i < r.stop

tactic: refine Nat.not_le.1 fun h =>
  Nat.not_le.2 h' <| (numElems_le_iff (Nat.pos_of_ne_zero step0)).2 h
state_before: r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start (numElems r) r.step
step0 : ¬r.step = 0
h' : i < (r.stop - r.start + r.step - 1) / r.step
⊢ r.start + r.step * i < r.stop
Theorem: AffineMap.right_vsub_lineMap
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← lineMap_apply_one_sub, left_vsub_lineMap]
state_before: k : Type u_3
V1 : Type u_1
P1 : Type u_2
V2 : Type ?u.565275
P2 : Type ?u.565278
V3 : Type ?u.565281
P3 : Type ?u.565284
V4 : Type ?u.565287
P4 : Type ?u.565290
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
c : k
⊢ p₁ -ᵥ ↑(lineMap p₀ p₁) c = (1 - c) • (p₁ -ᵥ p₀)
Theorem: MeasurableEquiv.map_symm_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [map_map e.symm.measurable e.measurable]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2129036
δ : Type ?u.2129039
ι : Type ?u.2129042
R : Type ?u.2129045
R' : Type ?u.2129048
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
e : α ≃ᵐ β
⊢ Measure.map (↑(symm e)) (Measure.map (↑e) μ) = μ
Theorem: Nat.WithBot.lt_one_iff_le_zero
File: Mathlib/Data/Nat/WithBot.lean

tactic: simpa using one_le_iff_zero_lt
state_before: x : WithBot ℕ
⊢ ¬x < 1 ↔ ¬x ≤ 0
Theorem: Fin.prod_univ_eq_prod_range
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.51670
γ : Type ?u.51673
inst✝ : CommMonoid α
f : ℕ → α
n : ℕ
⊢ ∀ (x : ℕ), x < n ↔ x ∈ range n

tactic: simp
state_before: α : Type u_1
β : Type ?u.51670
γ : Type ?u.51673
inst✝ : CommMonoid α
f : ℕ → α
n : ℕ
⊢ ∀ (i : Fin n), f ↑i = f ↑(↑(equivSubtype.trans (Equiv.subtypeEquivRight (_ : ∀ (a : ℕ), a < n ↔ a ∈ range n))) i)

tactic: rw [← attach_eq_univ, prod_attach]
state_before: α : Type u_1
β : Type ?u.51670
γ : Type ?u.51673
inst✝ : CommMonoid α
f : ℕ → α
n : ℕ
⊢ ∏ i : { x // x ∈ range n }, f ↑i = ∏ i in range n, f i
Theorem: BilinForm.nondegenerate_congr_iff
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: convert h.congr e.symm
state_before: R : Type ?u.1410438
M : Type ?u.1410441
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type ?u.1410477
M₁ : Type ?u.1410480
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type ?u.1411279
M₃ : Type ?u.1411282
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.1411870
K : Type ?u.1411873
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type u_3
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R₂ M₂'
B : BilinForm R₂ M₂
e : M₂ ≃ₗ[R₂] M₂'
h : Nondegenerate (↑(congr e) B)
⊢ Nondegenerate B

tactic: rw [congr_congr, e.self_trans_symm, congr_refl, LinearEquiv.refl_apply]
state_before: case h.e'_6
R : Type ?u.1410438
M : Type ?u.1410441
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type ?u.1410477
M₁ : Type ?u.1410480
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type ?u.1411279
M₃ : Type ?u.1411282
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.1411870
K : Type ?u.1411873
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type u_3
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R₂ M₂'
B : BilinForm R₂ M₂
e : M₂ ≃ₗ[R₂] M₂'
h : Nondegenerate (↑(congr e) B)
⊢ B = ↑(congr (LinearEquiv.symm e)) (↑(congr e) B)
Theorem: Std.RBNode.setRed_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: cases t <;> simp [setRed]
state_before: α : Type u_1
t : RBNode α
⊢ toList (setRed t) = toList t
Theorem: Fin.coe_of_injective_castLE_symm
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← coe_castLE]
state_before: n✝ m n k : ℕ
h : n ≤ k
i : Fin k
hi : i ∈ Set.range ↑(castLE h)
⊢ ↑(↑(Equiv.ofInjective ↑(castLE h) (_ : Injective ↑(castLE h))).symm { val := i, property := hi }) = ↑i

tactic: exact congr_arg Fin.val (Equiv.apply_ofInjective_symm _ _)
state_before: n✝ m n k : ℕ
h : n ≤ k
i : Fin k
hi : i ∈ Set.range ↑(castLE h)
⊢ ↑(↑(castLE ?h) (↑(Equiv.ofInjective ↑(castLE h) (_ : Injective ↑(castLE h))).symm { val := i, property := hi })) = ↑i

case h
n✝ m n k : ℕ
h : n ≤ k
i : Fin k
hi : i ∈ Set.range ↑(castLE h)
⊢ n ≤ ?m.75230

n✝ m n k : ℕ
h : n ≤ k
i : Fin k
hi : i ∈ Set.range ↑(castLE h)
⊢ ℕ
Theorem: PrimeSpectrum.union_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [zeroLocus_inf]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s s' : Set R
⊢ zeroLocus s ∪ zeroLocus s' = zeroLocus ↑(Ideal.span s ⊓ Ideal.span s')

tactic: simp
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s s' : Set R
⊢ zeroLocus s ∪ zeroLocus s' = zeroLocus ↑(Ideal.span s) ∪ zeroLocus ↑(Ideal.span s')
Theorem: QuotientGroup.mk'_eq_mk'
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: simp only [← _root_.eq_inv_mul_iff_mul_eq, exists_prop, exists_eq_right]
state_before: G : Type u
inst✝¹ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝ : Group H
x y : G
⊢ x⁻¹ * y ∈ N ↔ ∃ z, z ∈ N ∧ x * z = y
Theorem: Nat.floor_eq_on_Ico'
File: Mathlib/Algebra/Order/Floor.lean

tactic: exact_mod_cast floor_eq_on_Ico n x hx
state_before: F : Type ?u.41083
α : Type u_1
β : Type ?u.41089
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ n : ℕ
x : α
hx : x ∈ Ico (↑n) (↑n + 1)
⊢ ↑⌊x⌋₊ = ↑n
Theorem: MeasureTheory.OuterMeasure.dirac_caratheodory
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: by_cases ht : a ∈ t
state_before: α : Type u_1
a : α
s : Set α
x✝ : MeasurableSet s
t : Set α
⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s)

tactic: swap
state_before: case pos
α : Type u_1
a : α
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : a ∈ t
⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s)

case neg
α : Type u_1
a : α
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : ¬a ∈ t
⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s)

tactic: by_cases hs : a ∈ s <;> simp [*]
state_before: case pos
α : Type u_1
a : α
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : a ∈ t
⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s)

tactic: simp [ht]
state_before: case neg
α : Type u_1
a : α
s : Set α
x✝ : MeasurableSet s
t : Set α
ht : ¬a ∈ t
⊢ ↑(dirac a) t = ↑(dirac a) (t ∩ s) + ↑(dirac a) (t \ s)
Theorem: ENNReal.toNNReal_iInf
File: Mathlib/Data/Real/ENNReal.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type ?u.838531
β : Type ?u.838534
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
hf : ∀ (i : ι), f i ≠ ⊤
⊢ ENNReal.toNNReal (iInf f) = ⨅ (i : ι), ENNReal.toNNReal (f i)

tactic: rw [iInf_of_empty, top_toNNReal, NNReal.iInf_empty]
state_before: case inl
α : Type ?u.838531
β : Type ?u.838534
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
hf : ∀ (i : ι), f i ≠ ⊤
h✝ : IsEmpty ι
⊢ ENNReal.toNNReal (iInf f) = ⨅ (i : ι), ENNReal.toNNReal (f i)

tactic: lift f to ι → ℝ≥0 using hf
state_before: case inr
α : Type ?u.838531
β : Type ?u.838534
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
hf : ∀ (i : ι), f i ≠ ⊤
h✝ : Nonempty ι
⊢ ENNReal.toNNReal (iInf f) = ⨅ (i : ι), ENNReal.toNNReal (f i)

tactic: simp_rw [← coe_iInf, toNNReal_coe]
state_before: case inr.intro
α : Type ?u.838531
β : Type ?u.838534
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
g : ι → ℝ≥0∞
h✝ : Nonempty ι
f : ι → ℝ≥0
⊢ ENNReal.toNNReal (⨅ (i : ι), ↑(f i)) = ⨅ (i : ι), ENNReal.toNNReal ((fun i => ↑(f i)) i)
Theorem: MeasureTheory.lintegral_inter_add_diff
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_add_measure, restrict_inter_add_diff _ hB]
state_before: α : Type u_1
β : Type ?u.1027905
γ : Type ?u.1027908
δ : Type ?u.1027911
m : MeasurableSpace α
μ ν : Measure α
B : Set α
f : α → ℝ≥0∞
A : Set α
hB : MeasurableSet B
⊢ ((∫⁻ (x : α) in A ∩ B, f x ∂μ) + ∫⁻ (x : α) in A \ B, f x ∂μ) = ∫⁻ (x : α) in A, f x ∂μ
Theorem: NonUnitalSubsemiring.mem_map_equiv
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: convert @Set.mem_image_equiv _ _ (↑K) f.toEquiv x
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
f : R ≃+* S
K : NonUnitalSubsemiring R
x : S
⊢ x ∈ map (↑f) K ↔ ↑(RingEquiv.symm f) x ∈ K
Theorem: CategoryTheory.GlueData.t_inv
File: Mathlib/CategoryTheory/GlueData.lean

tactic: have eq : (pullbackSymmetry (D.f i i) (D.f i j)).hom = pullback.snd ≫ inv pullback.fst := by simp
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: have := D.cocycle i j i
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: rw [D.t'_iij, D.t'_jii, D.t'_iji, fst_eq_snd_of_mono_eq, eq] at this
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : t' D i j i ≫ t' D j i i ≫ t' D i i j = 𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: simp only [Category.assoc, IsIso.inv_hom_id_assoc] at this
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this :
  (pullback.fst ≫ t D i j ≫ inv pullback.snd) ≫
      (pullback.snd ≫ t D j i ≫ inv pullback.snd) ≫ pullback.snd ≫ inv pullback.fst =
    𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: rw [← IsIso.eq_inv_comp, ← Category.assoc, IsIso.comp_inv_eq] at this
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : pullback.fst ≫ t D i j ≫ t D j i ≫ inv pullback.fst = 𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: simpa using this
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : t D i j ≫ t D j i = (inv pullback.fst ≫ 𝟙 (pullback (f D i j) (f D i i))) ≫ pullback.fst
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
⊢ (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
Theorem: image2_lowerBounds_lowerBounds_subset
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, b, ha, hb, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ image2 f (lowerBounds s) (lowerBounds t) ⊆ lowerBounds (image2 f s t)

tactic: exact mem_lowerBounds_image2 h₀ h₁ ha hb
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
b : β
ha : a ∈ lowerBounds s
hb : b ∈ lowerBounds t
⊢ f a b ∈ lowerBounds (image2 f s t)
Theorem: Metric.mem_closedBall'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [dist_comm, mem_closedBall]
state_before: α : Type u
β : Type v
X : Type ?u.32147
ι : Type ?u.32150
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ y ∈ closedBall x ε ↔ dist x y ≤ ε
Theorem: Nat.count_eq_card_filter_range
File: Mathlib/Data/Nat/Count.lean

tactic: rw [count, List.countp_eq_length_filter]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n = card (filter p (range n))

tactic: rfl
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ List.length (List.filter (fun b => decide (p b)) (List.range n)) = card (filter p (range n))
Theorem: integrableOn_Icc_iff_integrableOn_Ioc
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type ?u.3994641
E : Type u_2
F : Type ?u.3994647
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ ↑↑μ {a} ≠ ⊤

tactic: exact ENNReal.zero_ne_top
state_before: α : Type u_1
β : Type ?u.3994641
E : Type u_2
F : Type ?u.3994647
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
Theorem: Memℓp.finset_sum
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: haveI : DecidableEq ι := Classical.decEq _
state_before: α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s : Finset ι
f : ι → (i : α) → E i
hf : ∀ (i : ι), i ∈ s → Memℓp (f i) p
⊢ Memℓp (fun a => ∑ i in s, f i a) p

tactic: revert hf
state_before: α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s : Finset ι
f : ι → (i : α) → E i
hf : ∀ (i : ι), i ∈ s → Memℓp (f i) p
this : DecidableEq ι
⊢ Memℓp (fun a => ∑ i in s, f i a) p

tactic: refine' Finset.induction_on s _ _
state_before: α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s : Finset ι
f : ι → (i : α) → E i
this : DecidableEq ι
⊢ (∀ (i : ι), i ∈ s → Memℓp (f i) p) → Memℓp (fun a => ∑ i in s, f i a) p

tactic: simp only [zero_mem_ℓp', Finset.sum_empty, imp_true_iff]
state_before: case refine'_1
α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s : Finset ι
f : ι → (i : α) → E i
this : DecidableEq ι
⊢ (∀ (i : ι), i ∈ ∅ → Memℓp (f i) p) → Memℓp (fun a => ∑ i in ∅, f i a) p

tactic: intro i s his ih hf
state_before: case refine'_2
α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s : Finset ι
f : ι → (i : α) → E i
this : DecidableEq ι
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    ¬a ∈ s →
      ((∀ (i : ι), i ∈ s → Memℓp (f i) p) → Memℓp (fun a => ∑ i in s, f i a) p) →
        (∀ (i : ι), i ∈ insert a s → Memℓp (f i) p) → Memℓp (fun a_3 => ∑ i in insert a s, f i a_3) p

tactic: simp only [his, Finset.sum_insert, not_false_iff]
state_before: case refine'_2
α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s✝ : Finset ι
f : ι → (i : α) → E i
this : DecidableEq ι
i : ι
s : Finset ι
his : ¬i ∈ s
ih : (∀ (i : ι), i ∈ s → Memℓp (f i) p) → Memℓp (fun a => ∑ i in s, f i a) p
hf : ∀ (i_1 : ι), i_1 ∈ insert i s → Memℓp (f i_1) p
⊢ Memℓp (fun a => ∑ i in insert i s, f i a) p

tactic: exact (hf i (s.mem_insert_self i)).add (ih fun j hj => hf j (Finset.mem_insert_of_mem hj))
state_before: case refine'_2
α : Type u_2
E : α → Type u_3
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_1
s✝ : Finset ι
f : ι → (i : α) → E i
this : DecidableEq ι
i : ι
s : Finset ι
his : ¬i ∈ s
ih : (∀ (i : ι), i ∈ s → Memℓp (f i) p) → Memℓp (fun a => ∑ i in s, f i a) p
hf : ∀ (i_1 : ι), i_1 ∈ insert i s → Memℓp (f i_1) p
⊢ Memℓp (fun a => f i a + ∑ i in s, f i a) p
Theorem: Rat.exists_eq_mul_div_num_and_eq_mul_div_den
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [← Rat.divInt_eq_div]
state_before: n d : ℤ
d_ne_zero : d ≠ 0
⊢ ↑n / ↑d = n /. d
Theorem: sq_eq_sq_iff_abs_eq_abs
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simp only [le_antisymm_iff, sq_le_sq]
state_before: β : Type ?u.267249
A : Type ?u.267252
G : Type ?u.267255
M : Type ?u.267258
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y✝ x y : R
⊢ x ^ 2 = y ^ 2 ↔ abs x = abs y
Theorem: map_finset_sup
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [sup_cons, sup_cons, map_sup, h, Function.comp_apply]
state_before: F : Type u_2
α : Type u_3
β : Type u_1
γ : Type ?u.18510
ι : Type u_4
κ : Type ?u.18516
inst✝⁴ : SemilatticeSup α
inst✝³ : OrderBot α
s✝¹ s₁ s₂ : Finset β
f✝ g✝ : β → α
a : α
inst✝² : SemilatticeSup β
inst✝¹ : OrderBot β
inst✝ : SupBotHomClass F α β
f : F
s✝ : Finset ι
g : ι → α
i : ι
s : Finset ι
x✝ : ¬i ∈ s
h : ↑f (sup s g) = sup s (↑f ∘ g)
⊢ ↑f (sup (cons i s x✝) g) = sup (cons i s x✝) (↑f ∘ g)
Theorem: Down.erase_mem_compression
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp_rw [mem_compression, erase_idem, and_self_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
hs : s ∈ 𝒜
⊢ erase s a ∈ 𝓓 a 𝒜

tactic: refine' (em _).imp_right fun h => ⟨h, _⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
hs : s ∈ 𝒜
⊢ erase s a ∈ 𝒜 ∨ ¬erase s a ∈ 𝒜 ∧ insert a (erase s a) ∈ 𝒜

tactic: rwa [insert_erase (erase_ne_self.1 (ne_of_mem_of_not_mem hs h).symm)]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
hs : s ∈ 𝒜
h : ¬erase s a ∈ 𝒜
⊢ insert a (erase s a) ∈ 𝒜
Theorem: imageToKernel_unop
File: Mathlib/Algebra/Homology/Opposite.lean

tactic: rw [← unop_comp, w, unop_zero]
state_before: V : Type ?u.7533
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.unop ≫ f.unop = 0

tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type ?u.7533
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0

tactic: ext
state_before: V : Type u_1
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop (_ : g.unop ≫ f.unop = 0) =
    (imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) (_ : f ≫ factorThruImage g = 0)).unop ≫
        (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv

tactic: dsimp only [imageUnopUnop]
state_before: case h
V : Type u_1
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop (_ : g.unop ≫ f.unop = 0) ≫ Subobject.arrow (kernelSubobject f.unop) =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) (_ : f ≫ factorThruImage g = 0)).unop ≫
          (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      Subobject.arrow (kernelSubobject f.unop)

tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelUnopUnop_inv, Category.assoc,
  imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, cokernel.π_desc, Iso.unop_inv,
  ← unop_comp, factorThruImage_comp_imageUnopOp_inv, Quiver.Hom.unop_op, imageSubobject_arrow]
state_before: case h
V : Type u_1
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop (_ : g.unop ≫ f.unop = 0) ≫ Subobject.arrow (kernelSubobject f.unop) =
    ((imageSubobjectIso g.unop ≪≫ (Iso.unop (imageUnopOp g)).symm).hom ≫
        (cokernel.desc f (factorThruImage g) (_ : f ≫ factorThruImage g = 0)).unop ≫
          (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      Subobject.arrow (kernelSubobject f.unop)
Theorem: CategoryTheory.Subobject.factorThru_add_sub_factorThru_right
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : Factors P (f + g)
wg : Factors P g
⊢ factorThru P (f + g) w - factorThru P g wg = factorThru P f (_ : Factors P f)

tactic: simp
state_before: case h
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : Factors P (f + g)
wg : Factors P g
⊢ (factorThru P (f + g) w - factorThru P g wg) ≫ arrow P = factorThru P f (_ : Factors P f) ≫ arrow P
Theorem: Finset.smul_univ
File: Mathlib/Data/Finset/Pointwise.lean

tactic: push_cast
state_before: F : Type ?u.857977
α : Type u_2
β : Type u_1
γ : Type ?u.857986
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : Finset.Nonempty s
⊢ ↑(s • univ) = ↑univ

tactic: exact Set.smul_univ hs
state_before: F : Type ?u.857977
α : Type u_2
β : Type u_1
γ : Type ?u.857986
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : Finset.Nonempty s
⊢ ↑s • Set.univ = Set.univ
Theorem: Set.ncard_univ
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' finite_or_infinite α with h h
state_before: α✝ : Type ?u.4996
β : Type ?u.4999
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
⊢ ncard univ = Nat.card α

tactic: rw [Nat.card_eq_zero_of_infinite, Infinite.ncard]
state_before: case inr
α✝ : Type ?u.4996
β : Type ?u.4999
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
h : Infinite α
⊢ ncard univ = Nat.card α

tactic: exact infinite_univ
state_before: case inr
α✝ : Type ?u.4996
β : Type ?u.4999
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
h : Infinite α
⊢ Set.Infinite univ

tactic: have hft := Fintype.ofFinite α
state_before: case inl
α✝ : Type ?u.4996
β : Type ?u.4999
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
h : Finite α
⊢ ncard univ = Nat.card α

tactic: rw [ncard_eq_toFinset_card, Finite.toFinset_univ, Finset.card_univ, Nat.card_eq_fintype_card]
state_before: case inl
α✝ : Type ?u.4996
β : Type ?u.4999
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
h : Finite α
hft : Fintype α
⊢ ncard univ = Nat.card α