tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.coevaluation_comp_leftAdjointMate
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: apply_fun (tensorRightHomEquiv _ (ᘁY) Y _).symm
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ η_ (ᘁY) Y ≫ ((ᘁf) ⊗ 𝟙 Y) = η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f)

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ ↑(tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁY) Y ≫ ((ᘁf) ⊗ 𝟙 Y)) =
    ↑(tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f))
Theorem: Ideal.sInf_minimalPrimes
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

tactic: rw [I.radical_eq_sInf]
state_before: R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ sInf (Ideal.minimalPrimes I) = radical I

tactic: apply le_antisymm
state_before: R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ sInf (Ideal.minimalPrimes I) = sInf {J | I ≤ J ∧ IsPrime J}

tactic: intro x hx
state_before: case a
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ sInf (Ideal.minimalPrimes I) ≤ sInf {J | I ≤ J ∧ IsPrime J}

tactic: rw [Ideal.mem_sInf] at hx⊢
state_before: case a
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
x : R
hx : x ∈ sInf (Ideal.minimalPrimes I)
⊢ x ∈ sInf {J | I ≤ J ∧ IsPrime J}

tactic: rintro J ⟨e, hJ⟩
state_before: case a
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ Ideal.minimalPrimes I → x ∈ I_1
⊢ ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsPrime J} → x ∈ I_1

tactic: obtain ⟨p, hp, hp'⟩ := Ideal.exists_minimalPrimes_le e
state_before: case a.intro
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J✝ : Ideal R
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ Ideal.minimalPrimes I → x ∈ I_1
J : Ideal R
e : I ≤ J
hJ : IsPrime J
⊢ x ∈ J

tactic: exact hp' (hx hp)
state_before: case a.intro.intro.intro
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J✝ : Ideal R
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ Ideal.minimalPrimes I → x ∈ I_1
J : Ideal R
e : I ≤ J
hJ : IsPrime J
p : Ideal R
hp : p ∈ Ideal.minimalPrimes I
hp' : p ≤ J
⊢ x ∈ J

tactic: apply sInf_le_sInf _
state_before: case a
R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ sInf {J | I ≤ J ∧ IsPrime J} ≤ sInf (Ideal.minimalPrimes I)

tactic: intro I hI
state_before: R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I J : Ideal R
⊢ Ideal.minimalPrimes I ⊆ {J | I ≤ J ∧ IsPrime J}

tactic: exact hI.1.symm
state_before: R : Type u_1
S : Type ?u.5834
inst✝¹ : CommRing R
inst✝ : CommRing S
I✝ J I : Ideal R
hI : I ∈ Ideal.minimalPrimes I✝
⊢ I ∈ {J | I✝ ≤ J ∧ IsPrime J}
Theorem: List.join_replicate_nil
File: Mathlib/Data/List/Basic.lean

tactic: induction n <;> [rfl; simp only [*, replicate, join, append_nil]]
state_before: ι : Type ?u.19480
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
⊢ join (replicate n []) = []
Theorem: Finset.card_mono
File: Mathlib/Data/Finset/Card.lean

tactic: apply card_le_of_subset
state_before: α : Type u_1
β : Type ?u.2628
s t : Finset α
a b : α
⊢ Monotone card
Theorem: AffineSubspace.eq_bot_or_nonempty
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [nonempty_iff_ne_bot]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Q = ⊥ ∨ Set.Nonempty ↑Q

tactic: apply eq_or_ne
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Q = ⊥ ∨ Q ≠ ⊥
Theorem: vadd_vsub_eq_sub_vsub
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [vadd_vsub_assoc, sub_eq_add_neg, neg_vsub_eq_vsub_rev]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p q : P
⊢ g +ᵥ p -ᵥ q = g - (q -ᵥ p)
Theorem: Cardinal.nfpBFamily_lt_ord_lift_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [mk_ordinal_out]
state_before: α : Type ?u.162925
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
ho : lift (card o) < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < ord c → f i hi b < ord c
a : Ordinal
⊢ lift (#(Quotient.out o).α) < c
Theorem: MeasureTheory.measure_add_measure_compl₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [← measure_union₀' hs aedisjoint_compl_right, union_compl_self]
state_before: ι : Type ?u.21287
α : Type u_1
β : Type ?u.21293
γ : Type ?u.21296
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
hs : NullMeasurableSet s
⊢ ↑↑μ s + ↑↑μ (sᶜ) = ↑↑μ univ
Theorem: Fin.reverse_induction_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [reverseInduction, dif_neg (_root_.ne_of_lt (Fin.castSucc_lt_last i))]
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C (last n)
hs : (i : Fin n) → C (succ i) → C (↑castSucc i)
i : Fin n
⊢ reverseInduction h0 hs (↑castSucc i) = hs i (reverseInduction h0 hs (succ i))

tactic: cases i
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C (last n)
hs : (i : Fin n) → C (succ i) → C (↑castSucc i)
i : Fin n
⊢ (let j := { val := ↑(↑castSucc i), isLt := (_ : ↑(↑castSucc i) < n) };
    let_fun x := (_ : n - ↑(↑castSucc i) < n + 1 - ↑(↑castSucc i));
    let_fun hi := (_ : ↑castSucc i = ↑castSucc j);
    _root_.cast (_ : C (↑castSucc j) = C (↑castSucc i)) (hs j (reverseInduction h0 hs (succ j)))) =
    hs i (reverseInduction h0 hs (succ i))

tactic: rfl
state_before: case mk
n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C (last n)
hs : (i : Fin n) → C (succ i) → C (↑castSucc i)
val✝ : ℕ
isLt✝ : val✝ < n
⊢ (let j :=
      { val := ↑(↑castSucc { val := val✝, isLt := isLt✝ }),
        isLt := (_ : ↑(↑castSucc { val := val✝, isLt := isLt✝ }) < n) };
    let_fun x :=
      (_ : n - ↑(↑castSucc { val := val✝, isLt := isLt✝ }) < n + 1 - ↑(↑castSucc { val := val✝, isLt := isLt✝ }));
    let_fun hi := (_ : ↑castSucc { val := val✝, isLt := isLt✝ } = ↑castSucc j);
    _root_.cast (_ : C (↑castSucc j) = C (↑castSucc { val := val✝, isLt := isLt✝ }))
      (hs j (reverseInduction h0 hs (succ j)))) =
    hs { val := val✝, isLt := isLt✝ } (reverseInduction h0 hs (succ { val := val✝, isLt := isLt✝ }))
Theorem: Denumerable.prod_ofNat_val
File: Mathlib/Logic/Denumerable.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
n : ℕ
⊢ ofNat (α × β) n = (ofNat α (unpair n).fst, ofNat β (unpair n).snd)
Theorem: PNat.gcdA'_coe
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [gcdA', gcdX, gcdW, XgcdType.w]
state_before: a b : ℕ+
⊢ ↑(gcdA' a b) = ↑(gcdW a b) + gcdX a b

tactic: rw [Nat.succ_eq_add_one, Nat.succ_eq_add_one, add_right_comm]
state_before: a b : ℕ+
⊢ succ ((xgcd a b).wp + (xgcd a b).x) = succ (xgcd a b).wp + (xgcd a b).x
Theorem: Polynomial.coeff_bit0
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: simp [bit0]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
⊢ coeff (bit0 p) n = bit0 (coeff p n)
Theorem: Dfinsupp.comapDomain'_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
f g : Π₀ (i : ι), β i
⊢ comapDomain' h hh' (f + g) = comapDomain' h hh' f + comapDomain' h hh' g

tactic: rw [add_apply, comapDomain'_apply, comapDomain'_apply, comapDomain'_apply, add_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
f g : Π₀ (i : ι), β i
i✝ : κ
⊢ ↑(comapDomain' h hh' (f + g)) i✝ = ↑(comapDomain' h hh' f + comapDomain' h hh' g) i✝
Theorem: isClopen_iff
File: Mathlib/Topology/Connected.lean

tactic: rw [← compl_compl s, h2, compl_empty]
state_before: α : Type u
β : Type v
ι : Type ?u.69730
π : ι → Type ?u.69735
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : Set α
hs : IsClopen s
h : ¬(s = ∅ ∨ s = univ)
h2 : sᶜ = ∅
⊢ s = univ

tactic: rintro (rfl | rfl) <;> [exact isClopen_empty; exact isClopen_univ]
state_before: α : Type u
β : Type v
ι : Type ?u.69730
π : ι → Type ?u.69735
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : Set α
⊢ s = ∅ ∨ s = univ → IsClopen s
Theorem: Matrix.toLinAlgEquiv_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [← LinearMap.toMatrixAlgEquiv_id v₁, Matrix.toLinAlgEquiv_toMatrixAlgEquiv]
state_before: R : Type u_3
inst✝⁹ : CommSemiring R
l : Type ?u.2576209
m : Type ?u.2576212
n : Type u_2
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_1
M₂ : Type ?u.2576236
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2576738
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
⊢ ↑(toLinAlgEquiv v₁) 1 = LinearMap.id
Theorem: Prod.isCompl_iff
File: Mathlib/Order/Disjoint.lean

tactic: simp_rw [isCompl_iff, Prod.disjoint_iff, Prod.codisjoint_iff, and_and_and_comm]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
x y : α × β
⊢ IsCompl x y ↔ IsCompl x.fst y.fst ∧ IsCompl x.snd y.snd
Theorem: MeasureTheory.unifIntegrable_of_tendsto_Lp
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: have : f = (fun _ => g) + fun n => f n - g := by ext1 n; simp
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
⊢ UnifIntegrable f p μ

tactic: rw [this]
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
this : f = (fun x => g) + fun n => f n - g
⊢ UnifIntegrable f p μ

tactic: refine' UnifIntegrable.add _ _ hp (fun _ => hg.aestronglyMeasurable)
    fun n => (hf n).1.sub hg.aestronglyMeasurable
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
this : f = (fun x => g) + fun n => f n - g
⊢ UnifIntegrable ((fun x => g) + fun n => f n - g) p μ

tactic: ext1 n
state_before: α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
⊢ f = (fun x => g) + fun n => f n - g

tactic: simp
state_before: case h
α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
n : ℕ
⊢ f n = ((fun x => g) + fun n => f n - g) n

tactic: exact unifIntegrable_const μ hp hp' hg
state_before: case refine'_1
α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
this : f = (fun x => g) + fun n => f n - g
⊢ UnifIntegrable (fun x => g) p μ

tactic: exact unifIntegrable_of_tendsto_Lp_zero μ hp hp' (fun n => (hf n).sub hg) hfg
state_before: case refine'_2
α : Type u_2
β : Type u_1
ι : Type ?u.499445
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), Memℒp (f n) p
hg : Memℒp g p
hfg : Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
this : f = (fun x => g) + fun n => f n - g
⊢ UnifIntegrable (fun n => f n - g) p μ
Theorem: CategoryTheory.Adjunction.homEquiv_symm_id
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X✝ : C
Y Y' X : D
⊢ ↑(homEquiv adj (G.obj X) X).symm (𝟙 (G.obj X)) = adj.counit.app X
Theorem: Matrix.fromBlocks_smul
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_4
m : Type u_5
n : Type u_3
o : Type u_6
p : Type ?u.23629
q : Type ?u.23632
m' : o → Type ?u.23637
n' : o → Type ?u.23642
p' : o → Type ?u.23647
R : Type u_1
S : Type ?u.23653
α : Type u_2
β : Type ?u.23659
inst✝ : SMul R α
x : R
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
⊢ x • fromBlocks A B C D = fromBlocks (x • A) (x • B) (x • C) (x • D)

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp [fromBlocks]
state_before: case a.h
l : Type u_4
m : Type u_5
n : Type u_3
o : Type u_6
p : Type ?u.23629
q : Type ?u.23632
m' : o → Type ?u.23637
n' : o → Type ?u.23642
p' : o → Type ?u.23647
R : Type u_1
S : Type ?u.23653
α : Type u_2
β : Type ?u.23659
inst✝ : SMul R α
x : R
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (x • fromBlocks A B C D) i j = fromBlocks (x • A) (x • B) (x • C) (x • D) i j
Theorem: Fin.equiv_iff_eq
File: Mathlib/Data/Fintype/Card.lean

tactic: simpa using Fintype.card_congr h
state_before: α : Type ?u.11219
β : Type ?u.11222
γ : Type ?u.11225
m n : ℕ
x✝ : Nonempty (Fin m ≃ Fin n)
h : Fin m ≃ Fin n
⊢ m = n
Theorem: Finset.not_isDiag_mk'_of_mem_offDiag
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [Sym2.isDiag_iff_proj_eq]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b : α
a : α × α
h : a ∈ offDiag s
⊢ ¬Sym2.IsDiag (Quotient.mk (Sym2.Rel.setoid α) a)

tactic: exact (mem_offDiag.1 h).2.2
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a✝ b : α
a : α × α
h : a ∈ offDiag s
⊢ ¬a.fst = a.snd
Theorem: Filter.prod_map_right
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [← prod_map_map_eq', map_id]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.28964
ι : Sort ?u.28967
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : β → γ
F : Filter α
G : Filter β
⊢ F ×ˢ map f G = map (Prod.map id f) (F ×ˢ G)
Theorem: List.rdrop_zero
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rdrop]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rdrop l 0 = l
Theorem: Int.negSucc_not_pos
File: Std/Data/Int/Lemmas.lean

tactic: simp only [Int.not_lt, iff_false]
state_before: n : Nat
⊢ 0 < -[n+1] ↔ False

tactic: constructor
state_before: n : Nat
⊢ -[n+1] ≤ 0
Theorem: Filter.Eventually.exists_gt
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [exists_prop, gt_iff_lt, and_comm] using
  ((h.filter_mono (@nhdsWithin_le_nhds _ _ a (Ioi a))).and self_mem_nhdsWithin).exists
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : DenselyOrdered α
a✝ b : α
s : Set α
inst✝ : NoMaxOrder α
a : α
p : α → Prop
h : ∀ᶠ (x : α) in 𝓝 a, p x
⊢ ∃ b, b > a ∧ p b
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.mul
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [mul_eq_map₂]
state_before: α : Type u_2
β✝ : Type ?u.916695
γ : Type ?u.916698
δ : Type ?u.916701
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_1
inst✝ : MonoidWithZero β
f g : α →ₛ β
hf : SimpleFunc.FinMeasSupp f μ
hg : SimpleFunc.FinMeasSupp g μ
⊢ SimpleFunc.FinMeasSupp (f * g) μ

tactic: exact hf.map₂ hg (MulZeroClass.zero_mul 0)
state_before: α : Type u_2
β✝ : Type ?u.916695
γ : Type ?u.916698
δ : Type ?u.916701
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_1
inst✝ : MonoidWithZero β
f g : α →ₛ β
hf : SimpleFunc.FinMeasSupp f μ
hg : SimpleFunc.FinMeasSupp g μ
⊢ SimpleFunc.FinMeasSupp (map (fun p => p.fst * p.snd) (pair f g)) μ
Theorem: Pi.mulSupport_mulSingle_of_ne
File: Mathlib/Algebra/Support.lean

tactic: rwa [mem_mulSupport, hx, mulSingle_eq_same]
state_before: A : Type u_2
B : Type u_1
inst✝¹ : DecidableEq A
inst✝ : One B
a : A
b : B
h : b ≠ 1
x : A
hx : x = a
⊢ x ∈ mulSupport (mulSingle a b)
Theorem: CategoryTheory.NatTrans.mapHomologicalComplex_id
File: Mathlib/Algebra/Homology/Additive.lean

tactic: aesop_cat
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_3
inst✝² : Category W
inst✝¹ : Preadditive W
c : ComplexShape ι
F : V ⥤ W
inst✝ : Functor.Additive F
⊢ mapHomologicalComplex (𝟙 F) c = 𝟙 (Functor.mapHomologicalComplex F c)
Theorem: isLittleO_abs_log_rpow_rpow_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simp [abs_of_nonpos, log_nonpos hx.1 hx.2]
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Icc 0 1
⊢ x ∈ {x | (fun x => ((fun x => log x ^ r) ∘ fun x => x⁻¹) x = (fun x => abs (log x) ^ r) x) x}

tactic: rw [Function.comp_apply, inv_rpow hx.out.le, rpow_neg hx.out.le, inv_inv]
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((fun x => x ^ (-s)) ∘ fun x => x⁻¹) x = (fun x => x ^ s) x
Theorem: Real.tendsto_log_atTop
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: simpa only [log_exp] using tendsto_id
state_before: x y : ℝ
⊢ Tendsto (fun x => log (exp x)) atTop atTop
Theorem: Rat.cast_pos_of_pos
File: Mathlib/Data/Rat/Cast.lean

tactic: rw [Rat.cast_def]
state_before: F : Type ?u.54964
ι : Type ?u.54967
α : Type ?u.54970
β : Type ?u.54973
K : Type u_1
inst✝ : LinearOrderedField K
r : ℚ
hr : 0 < r
⊢ 0 < ↑r

tactic: exact div_pos (Int.cast_pos.2 <| num_pos_iff_pos.2 hr) (Nat.cast_pos.2 r.pos)
state_before: F : Type ?u.54964
ι : Type ?u.54967
α : Type ?u.54970
β : Type ?u.54973
K : Type u_1
inst✝ : LinearOrderedField K
r : ℚ
hr : 0 < r
⊢ 0 < ↑r.num / ↑r.den
Theorem: summable_iff_not_tendsto_nat_atTop_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← not_iff_not, Classical.not_not, not_summable_iff_tendsto_nat_atTop_of_nonneg hf]
state_before: α : Type ?u.345613
β : Type ?u.345616
γ : Type ?u.345619
f : ℕ → ℝ
hf : ∀ (n : ℕ), 0 ≤ f n
⊢ Summable f ↔ ¬Tendsto (fun n => ∑ i in Finset.range n, f i) atTop atTop
Theorem: LieSubmodule.mem_sup
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← mem_coeSubmodule, sup_coe_toSubmodule, Submodule.mem_sup]
state_before: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ x ∈ N ⊔ N' ↔ ∃ y, y ∈ N ∧ ∃ z, z ∈ N' ∧ y + z = x

tactic: exact Iff.rfl
state_before: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ (∃ y, y ∈ ↑N ∧ ∃ z, z ∈ ↑N' ∧ y + z = x) ↔ ∃ y, y ∈ N ∧ ∃ z, z ∈ N' ∧ y + z = x
Theorem: Ideal.Filtration.stable_iff_exists_pow_smul_eq_of_ge
File: Mathlib/RingTheory/Filtration.lean

tactic: refine' ⟨Stable.exists_pow_smul_eq_of_ge, fun h => ⟨h.choose, fun n hn => _⟩⟩
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ Stable F ↔ ∃ n₀, ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀

tactic: rw [h.choose_spec n hn, h.choose_spec (n + 1) (by linarith), smul_smul, ← pow_succ,
  tsub_add_eq_add_tsub hn]
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h✝ : Stable F
h : ∃ n₀, ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀
n : ℕ
hn : n ≥ Exists.choose h
⊢ I • N F n = N F (n + 1)

tactic: linarith
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h✝ : Stable F
h : ∃ n₀, ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀
n : ℕ
hn : n ≥ Exists.choose h
⊢ n + 1 ≥ Exists.choose h
Theorem: Pretrivialization.symmₗ_linearMapAt
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [e.linearMapAt_def_of_mem hb]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y✝ : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
y : E b
⊢ ↑(Pretrivialization.symmₗ R e b) (↑(Pretrivialization.linearMapAt R e b) y) = y

tactic: exact (e.linearEquivAt R b hb).left_inv y
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y✝ : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
y : E b
⊢ ↑(Pretrivialization.symmₗ R e b) (↑↑(linearEquivAt R e b hb) y) = y
Theorem: Function.mulSupport_pow
File: Mathlib/Algebra/Support.lean

tactic: induction' n with n hfn
state_before: α : Type u_2
β : Type ?u.21041
A : Type ?u.21044
B : Type ?u.21047
M : Type u_1
N : Type ?u.21053
P : Type ?u.21056
R : Type ?u.21059
S : Type ?u.21062
G : Type ?u.21065
M₀ : Type ?u.21068
G₀ : Type ?u.21071
ι : Sort ?u.21074
inst✝ : Monoid M
f : α → M
n : ℕ
⊢ (mulSupport fun x => f x ^ n) ⊆ mulSupport f

tactic: simp [pow_zero, mulSupport_one]
state_before: case zero
α : Type u_2
β : Type ?u.21041
A : Type ?u.21044
B : Type ?u.21047
M : Type u_1
N : Type ?u.21053
P : Type ?u.21056
R : Type ?u.21059
S : Type ?u.21062
G : Type ?u.21065
M₀ : Type ?u.21068
G₀ : Type ?u.21071
ι : Sort ?u.21074
inst✝ : Monoid M
f : α → M
⊢ (mulSupport fun x => f x ^ Nat.zero) ⊆ mulSupport f

tactic: simpa only [pow_succ] using (mulSupport_mul f _).trans (union_subset Subset.rfl hfn)
state_before: case succ
α : Type u_2
β : Type ?u.21041
A : Type ?u.21044
B : Type ?u.21047
M : Type u_1
N : Type ?u.21053
P : Type ?u.21056
R : Type ?u.21059
S : Type ?u.21062
G : Type ?u.21065
M₀ : Type ?u.21068
G₀ : Type ?u.21071
ι : Sort ?u.21074
inst✝ : Monoid M
f : α → M
n : ℕ
hfn : (mulSupport fun x => f x ^ n) ⊆ mulSupport f
⊢ (mulSupport fun x => f x ^ Nat.succ n) ⊆ mulSupport f
Theorem: Set.biInter_inter
File: Mathlib/Data/Set/Lattice.lean

tactic: haveI : Nonempty s := hs.to_subtype
state_before: α✝ : Type ?u.102784
β : Type ?u.102787
γ : Type ?u.102790
ι✝ : Sort ?u.102793
ι' : Sort ?u.102796
ι₂ : Sort ?u.102799
κ : ι✝ → Sort ?u.102804
κ₁ : ι✝ → Sort ?u.102809
κ₂ : ι✝ → Sort ?u.102814
κ' : ι' → Sort ?u.102819
ι : Type u_1
α : Type u_2
s : Set ι
hs : Set.Nonempty s
f : ι → Set α
t : Set α
⊢ (⋂ (i : ι) (_ : i ∈ s), f i ∩ t) = (⋂ (i : ι) (_ : i ∈ s), f i) ∩ t

tactic: simp [biInter_eq_iInter, ← iInter_inter]
state_before: α✝ : Type ?u.102784
β : Type ?u.102787
γ : Type ?u.102790
ι✝ : Sort ?u.102793
ι' : Sort ?u.102796
ι₂ : Sort ?u.102799
κ : ι✝ → Sort ?u.102804
κ₁ : ι✝ → Sort ?u.102809
κ₂ : ι✝ → Sort ?u.102814
κ' : ι' → Sort ?u.102819
ι : Type u_1
α : Type u_2
s : Set ι
hs : Set.Nonempty s
f : ι → Set α
t : Set α
this : Nonempty ↑s
⊢ (⋂ (i : ι) (_ : i ∈ s), f i ∩ t) = (⋂ (i : ι) (_ : i ∈ s), f i) ∩ t