tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.AECover.lintegral_tendsto_of_nat
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: have lim₁ := lintegral_tendsto_of_monotone_of_nat hφ.biInter_Ici_aecover
  (fun i j hij => biInter_subset_biInter_left (Ici_subset_Ici.mpr hij)) hfm
state_before: α : Type u_1
ι : Type ?u.93118
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
φ : ℕ → Set α
hφ : AECover μ atTop φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
⊢ Tendsto (fun x => ∫⁻ (x : α) in φ x, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))

tactic: have lim₂ := lintegral_tendsto_of_monotone_of_nat hφ.biUnion_Iic_aecover
  (fun i j hij => biUnion_subset_biUnion_left (Iic_subset_Iic.mpr hij)) hfm
state_before: α : Type u_1
ι : Type ?u.93118
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
φ : ℕ → Set α
hφ : AECover μ atTop φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
lim₁ : Tendsto (fun i => ∫⁻ (x : α) in ⋂ (k : ℕ) (_ : k ∈ Ici i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
⊢ Tendsto (fun x => ∫⁻ (x : α) in φ x, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))

tactic: refine tendsto_of_tendsto_of_tendsto_of_le_of_le lim₁ lim₂ (fun n ↦ ?_) fun n ↦ ?_
state_before: α : Type u_1
ι : Type ?u.93118
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
φ : ℕ → Set α
hφ : AECover μ atTop φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
lim₁ : Tendsto (fun i => ∫⁻ (x : α) in ⋂ (k : ℕ) (_ : k ∈ Ici i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
lim₂ : Tendsto (fun i => ∫⁻ (x : α) in ⋃ (k : ℕ) (_ : k ∈ Iic i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
⊢ Tendsto (fun x => ∫⁻ (x : α) in φ x, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))

tactic: exacts [lintegral_mono_set (biInter_subset_of_mem left_mem_Ici),
  lintegral_mono_set (subset_biUnion_of_mem right_mem_Iic)]
state_before: case refine_1
α : Type u_1
ι : Type ?u.93118
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
φ : ℕ → Set α
hφ : AECover μ atTop φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
lim₁ : Tendsto (fun i => ∫⁻ (x : α) in ⋂ (k : ℕ) (_ : k ∈ Ici i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
lim₂ : Tendsto (fun i => ∫⁻ (x : α) in ⋃ (k : ℕ) (_ : k ∈ Iic i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
n : ℕ
⊢ (∫⁻ (x : α) in ⋂ (k : ℕ) (_ : k ∈ Ici n), φ k, f x ∂μ) ≤ ∫⁻ (x : α) in φ n, f x ∂μ

case refine_2
α : Type u_1
ι : Type ?u.93118
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
φ : ℕ → Set α
hφ : AECover μ atTop φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
lim₁ : Tendsto (fun i => ∫⁻ (x : α) in ⋂ (k : ℕ) (_ : k ∈ Ici i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
lim₂ : Tendsto (fun i => ∫⁻ (x : α) in ⋃ (k : ℕ) (_ : k ∈ Iic i), φ k, f x ∂μ) atTop (𝓝 (∫⁻ (x : α), f x ∂μ))
n : ℕ
⊢ (∫⁻ (x : α) in φ n, f x ∂μ) ≤ ∫⁻ (x : α) in ⋃ (k : ℕ) (_ : k ∈ Iic n), φ k, f x ∂μ
Theorem: NNReal.summable_rpow_inv
File: Mathlib/Analysis/PSeries.lean

tactic: simp [← NNReal.summable_coe]
state_before: p : ℝ
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p
Theorem: Set.preimage_mul_right_one'
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp
state_before: F : Type ?u.134683
α : Type u_1
β : Type ?u.134689
γ : Type ?u.134692
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * b⁻¹) ⁻¹' 1 = {b}
Theorem: MonoidHom.map_finprod_of_preimage_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: by_cases hg : (mulSupport <| g ∘ PLift.down).Finite
state_before: G : Type ?u.84392
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.84404
ι : Sort ?u.84407
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
hf : ∀ (x : M), ↑f x = 1 → x = 1
g : α → M
⊢ ↑f (∏ᶠ (i : α), g i) = ∏ᶠ (i : α), ↑f (g i)

tactic: rw [finprod, dif_neg, f.map_one, finprod, dif_neg]
state_before: case neg
G : Type ?u.84392
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.84404
ι : Sort ?u.84407
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
hf : ∀ (x : M), ↑f x = 1 → x = 1
g : α → M
hg : ¬Set.Finite (mulSupport (g ∘ PLift.down))
⊢ ↑f (∏ᶠ (i : α), g i) = ∏ᶠ (i : α), ↑f (g i)

tactic: exacts [Infinite.mono (fun x hx => mt (hf (g x.down)) hx) hg, hg]
state_before: case neg.hnc
G : Type ?u.84392
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.84404
ι : Sort ?u.84407
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
hf : ∀ (x : M), ↑f x = 1 → x = 1
g : α → M
hg : ¬Set.Finite (mulSupport (g ∘ PLift.down))
⊢ ¬Set.Finite (mulSupport ((fun i => ↑f (g i)) ∘ PLift.down))

case neg.hnc
G : Type ?u.84392
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.84404
ι : Sort ?u.84407
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
hf : ∀ (x : M), ↑f x = 1 → x = 1
g : α → M
hg : ¬Set.Finite (mulSupport (g ∘ PLift.down))
⊢ ¬Set.Finite (mulSupport ((fun i => g i) ∘ PLift.down))

tactic: exact f.map_finprod_pLift g hg
state_before: case pos
G : Type ?u.84392
M : Type u_1
N : Type u_2
α : Sort u_3
β : Sort ?u.84404
ι : Sort ?u.84407
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : M →* N
hf : ∀ (x : M), ↑f x = 1 → x = 1
g : α → M
hg : Set.Finite (mulSupport (g ∘ PLift.down))
⊢ ↑f (∏ᶠ (i : α), g i) = ∏ᶠ (i : α), ↑f (g i)
Theorem: star_mul_star
File: Mathlib/Algebra/Star/Basic.lean

tactic: rw [star_mul, star_star]
state_before: R : Type u
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x y : R
⊢ star (x * star y) = y * star x
Theorem: Orthonormal.inner_left_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical!
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1958519
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
⊢ inner (∑ i in s, l i • v i) (v i) = ↑(starRingEnd 𝕜) (l i)

tactic: simp only [sum_inner, inner_smul_left, orthonormal_iff_ite.mp hv, hi, mul_boole,
  Finset.sum_ite_eq', if_true]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1958519
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
em✝ : (a : Prop) → Decidable a
⊢ inner (∑ i in s, l i • v i) (v i) = ↑(starRingEnd 𝕜) (l i)
Theorem: CategoryTheory.Functor.additive_of_preservesBinaryBiproducts
File: Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean

tactic: rw [biprod.add_eq_lift_id_desc,  F.map_comp, ← biprod.lift_mapBiprod,
  ←  biprod.mapBiprod_hom_desc, Category.assoc, Iso.inv_hom_id_assoc, F.map_id,
  biprod.add_eq_lift_id_desc]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category C
inst✝⁵ : Category D
inst✝⁴ : Preadditive C
inst✝³ : Preadditive D
F : C ⥤ D
inst✝² : HasBinaryBiproducts C
inst✝¹ : PreservesZeroMorphisms F
inst✝ : PreservesBinaryBiproducts F
X Y : C
f g : X ⟶ Y
⊢ F.map (f + g) = F.map f + F.map g
Theorem: PerfectClosure.add_aux_left
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_add,
  Nat.succ_add]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).fst + y.fst, (↑(frobenius K p)^[y.fst]) (n, x).snd + (↑(frobenius K p)^[(n, x).fst]) y.snd)
    ((n + 1, ↑(frobenius K p) x).fst + y.fst,
      (↑(frobenius K p)^[y.fst]) (n + 1, ↑(frobenius K p) x).snd +
        (↑(frobenius K p)^[(n + 1, ↑(frobenius K p) x).fst]) y.snd)

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).fst + y.fst, (↑(frobenius K p)^[y.fst]) (n, x).snd + (↑(frobenius K p)^[(n, x).fst]) y.snd)
    (Nat.succ (n + y.fst), ↑(frobenius K p) ((↑(frobenius K p)^[y.fst]) x + (↑(frobenius K p)^[n]) y.snd))
Theorem: isAtom_iff
File: Mathlib/Order/Atoms.lean

tactic: simp only [Ne.def, @not_imp_comm (b = ⊥), not_imp, lt_iff_le_not_le]
state_before: α : Type u_1
β : Type ?u.1175
inst✝¹ : Preorder α
inst✝ : OrderBot α
a✝ b✝ x a b : α
⊢ b < a → b = ⊥ ↔ b ≠ ⊥ → b ≤ a → a ≤ b
Theorem: SimpleGraph.Subgraph.deleteEdges_empty_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp
state_before: ι : Sort ?u.243521
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' ∅ = G'
Theorem: Set.Finite.toFinset_compl
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht : Set.Finite t
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hs : Set.Finite s
h : Set.Finite (sᶜ)
⊢ Finite.toFinset h = Finite.toFinset hsᶜ

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : Set.Finite s
ht : Set.Finite t
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hs : Set.Finite s
h : Set.Finite (sᶜ)
a✝ : α
⊢ a✝ ∈ Finite.toFinset h ↔ a✝ ∈ Finite.toFinset hsᶜ
Theorem: lp.norm_compl_sum_single
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: linarith [lp.norm_sub_norm_compl_sub_single hp f s]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type ?u.956057
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
hp : 0 < ENNReal.toReal p
f : { x // x ∈ lp E p }
s : Finset α
⊢ ‖f - ∑ i in s, lp.single p i (↑f i)‖ ^ ENNReal.toReal p = ‖f‖ ^ ENNReal.toReal p - ∑ i in s, ‖↑f i‖ ^ ENNReal.toReal p
Theorem: Int.mul_zero
File: Std/Data/Int/Lemmas.lean

tactic: cases a <;> rfl
state_before: a : Int
⊢ a * 0 = 0
Theorem: Associates.count_self
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp [factors_self hp, Associates.count_some hp]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
p : Associates α
hp : Irreducible p
⊢ count p (factors p) = 1
Theorem: Nat.floor_lt_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [Nat.cast_one]
state_before: F : Type ?u.20203
α : Type u_1
β : Type ?u.20209
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : 0 ≤ a
⊢ a < ↑1 ↔ a < 1
Theorem: MonoidHom.transfer_center_eq_pow
File: Mathlib/GroupTheory/Transfer.lean

tactic: rw [← mul_right_inj, hk, mul_inv_cancel_right]
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type ?u.848720
inst✝¹ : CommGroup A
ϕ : { x // x ∈ H } →* A
T : ↑(leftTransversals ↑H)
inst✝ : FiniteIndex (center G)
g : G
k : ℕ
x✝ : G
hk : x✝⁻¹ * g ^ k * x✝ ∈ center G
⊢ x✝⁻¹ * g ^ k * x✝ = g ^ k
Theorem: GaloisInsertion.isAtom_iff
File: Mathlib/Order/Atoms.lean

tactic: refine' ⟨fun hla => _, fun ha => gi.isAtom_of_u_bot hbot ((h_atom a ha).symm ▸ ha)⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
a : α
⊢ IsAtom (l a) ↔ IsAtom a

tactic: obtain ⟨a', ha', hab'⟩ :=
  (eq_bot_or_exists_atom_le (u (l a))).resolve_left (hbot ▸ fun h => hla.1 (gi.u_injective h))
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
a : α
hla : IsAtom (l a)
⊢ IsAtom a

tactic: have :=
  (hla.le_iff.mp <| (gi.l_u_eq (l a) ▸ gi.gc.monotone_l hab' : l a' ≤ l a)).resolve_left fun h =>
    ha'.1 (hbot ▸ h_atom a' ha' ▸ congr_arg u h)
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
a : α
hla : IsAtom (l a)
a' : α
ha' : IsAtom a'
hab' : a' ≤ u (l a)
⊢ IsAtom a

tactic: have haa' : a = a' :=
  (ha'.le_iff.mp <|
        (gi.gc.le_u_l a).trans_eq (h_atom a' ha' ▸ congr_arg u this.symm)).resolve_left
    (mt (congr_arg l) (gi.gc.l_bot.symm ▸ hla.1))
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
a : α
hla : IsAtom (l a)
a' : α
ha' : IsAtom a'
hab' : a' ≤ u (l a)
this : l a' = l a
⊢ IsAtom a

tactic: exact haa'.symm ▸ ha'
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
a : α
hla : IsAtom (l a)
a' : α
ha' : IsAtom a'
hab' : a' ≤ u (l a)
this : l a' = l a
haa' : a = a'
⊢ IsAtom a
Theorem: dualTensorHomEquivOfBasis_apply
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
x : Dual R M ⊗[R] N
⊢ ↑(dualTensorHomEquivOfBasis b) x = ↑(dualTensorHom R M N) x

tactic: rfl
state_before: case h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
x : Dual R M ⊗[R] N
x✝ : M
⊢ ↑(↑(dualTensorHomEquivOfBasis b) x) x✝ = ↑(↑(dualTensorHom R M N) x) x✝
Theorem: Int.bit_coe_nat
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [bit_val, Nat.bit_val]
state_before: b : Bool
n : ℕ
⊢ bit b ↑n = ↑(Nat.bit b n)

tactic: cases b <;> rfl
state_before: b : Bool
n : ℕ
⊢ (2 * ↑n + bif b then 1 else 0) = ↑(2 * n + bif b then 1 else 0)
Theorem: Polynomial.natTrailingDegree_le_of_ne_zero
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: have : WithTop.some (natTrailingDegree p) = Nat.cast (natTrailingDegree p) := rfl
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
⊢ natTrailingDegree p ≤ n

tactic: rw [← WithTop.coe_le_coe, this, ← trailingDegree_eq_natTrailingDegree]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
this : ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
⊢ natTrailingDegree p ≤ n

tactic: exact le_trailingDegree_of_ne_zero h
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
this : ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
⊢ trailingDegree p ≤ ↑n

tactic: intro h
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
this : ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
⊢ p ≠ 0

tactic: subst h
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h✝ : coeff p n ≠ 0
this : ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
h : p = 0
⊢ False

tactic: exact h rfl
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
q r : R[X]
h : coeff 0 n ≠ 0
this : ↑(natTrailingDegree 0) = ↑(natTrailingDegree 0)
⊢ False
Theorem: LinearMap.iSup_range_stdBasis_eq_iInf_ker_proj
File: Mathlib/LinearAlgebra/StdBasis.lean

tactic: refine' le_antisymm (iSup_range_stdBasis_le_iInf_ker_proj _ _ _ _ hd) _
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
hd : Disjoint I J
hu : Set.univ ⊆ I ∪ J
hI : Set.Finite I
⊢ (⨆ (i : ι) (_ : i ∈ I), range (stdBasis R φ i)) = ⨅ (i : ι) (_ : i ∈ J), ker (proj i)

tactic: have : Set.univ ⊆ ↑hI.toFinset ∪ J := by rwa [hI.coe_toFinset]
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
hd : Disjoint I J
hu : Set.univ ⊆ I ∪ J
hI : Set.Finite I
⊢ (⨅ (i : ι) (_ : i ∈ J), ker (proj i)) ≤ ⨆ (i : ι) (_ : i ∈ I), range (stdBasis R φ i)

tactic: refine' le_trans (iInf_ker_proj_le_iSup_range_stdBasis R φ this) (iSup_mono fun i => _)
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
hd : Disjoint I J
hu : Set.univ ⊆ I ∪ J
hI : Set.Finite I
this : Set.univ ⊆ ↑(Set.Finite.toFinset hI) ∪ J
⊢ (⨅ (i : ι) (_ : i ∈ J), ker (proj i)) ≤ ⨆ (i : ι) (_ : i ∈ I), range (stdBasis R φ i)

tactic: rw [Set.Finite.mem_toFinset]
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
hd : Disjoint I J
hu : Set.univ ⊆ I ∪ J
hI : Set.Finite I
this : Set.univ ⊆ ↑(Set.Finite.toFinset hI) ∪ J
i : ι
⊢ (⨆ (_ : i ∈ Set.Finite.toFinset hI), range (stdBasis R φ i)) ≤ ⨆ (_ : i ∈ I), range (stdBasis R φ i)

tactic: rwa [hI.coe_toFinset]
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I J : Set ι
hd : Disjoint I J
hu : Set.univ ⊆ I ∪ J
hI : Set.Finite I
⊢ Set.univ ⊆ ↑(Set.Finite.toFinset hI) ∪ J
Theorem: SymAlg.unsym_mul
File: Mathlib/Algebra/Symmetrized.lean

tactic: rfl
state_before: α : Type u_1
inst✝⁴ : Mul α
inst✝³ : Add α
inst✝² : One α
inst✝¹ : OfNat α 2
inst✝ : Invertible 2
a b : αˢʸᵐ
⊢ ↑unsym (a * b) = ⅟2 * (↑unsym a * ↑unsym b + ↑unsym b * ↑unsym a)
Theorem: Basis.orientation_comp_linearEquiv_eq_neg_iff_det_neg
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [orientation_map, e.map_orientation_eq_det_inv_smul, units_inv_smul, units_smul_eq_neg_iff,
  LinearEquiv.coe_det]
state_before: R : Type u_2
inst✝⁴ : LinearOrderedCommRing R
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
f : M ≃ₗ[R] M
⊢ Basis.orientation (Basis.map e f) = -Basis.orientation e ↔ ↑LinearMap.det ↑f < 0
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_leftUnitor_inv_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (λ_ X).inv.fst = (λ_ X.fst).inv

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).inv.fst = (λ_ (fst✝, snd✝).fst).inv
Theorem: Polynomial.support_neg
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
p : R[X]
⊢ support (-p) = support p

tactic: rw [← ofFinsupp_neg, support, support]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support (-{ toFinsupp := toFinsupp✝ }) = support { toFinsupp := toFinsupp✝ }

tactic: apply Finsupp.support_neg
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ (match { toFinsupp := -toFinsupp✝ } with
    | { toFinsupp := p } => p.support) =
    match { toFinsupp := toFinsupp✝ } with
    | { toFinsupp := p } => p.support
Theorem: LazyList.append_assoc
File: Mathlib/Data/LazyList/Basic.lean

tactic: induction' xs using LazyList.rec with _ _ _ _ ih
state_before: α : Type u_1
xs ys zs : LazyList α
⊢ append (append xs { fn := fun x => ys }) { fn := fun x => zs } =
    append xs { fn := fun x => append ys { fn := fun x => zs } }

tactic: rfl
state_before: case nil
α : Type u_1
ys zs : LazyList α
⊢ append (append nil { fn := fun x => ys }) { fn := fun x => zs } =
    append nil { fn := fun x => append ys { fn := fun x => zs } }

tactic: simpa only [append, cons.injEq, true_and]
state_before: case cons
α : Type u_1
xs ys zs : LazyList α
hd✝ : α
tl✝ : Thunk (LazyList α)
tl_ih✝ : ?m.66098 tl✝
⊢ append (append (cons hd✝ tl✝) { fn := fun x => ys }) { fn := fun x => zs } =
    append (cons hd✝ tl✝) { fn := fun x => append ys { fn := fun x => zs } }

tactic: ext
state_before: case mk
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    append (append (fn✝ a) { fn := fun x => ys }) { fn := fun x => zs } =
      append (fn✝ a) { fn := fun x => append ys { fn := fun x => zs } }
⊢ {
      fn := fun x =>
        append (Thunk.get { fn := fun x => append (Thunk.get { fn := fn✝ }) { fn := fun x => ys } })
          { fn := fun x => zs } } =
    { fn := fun x => append (Thunk.get { fn := fn✝ }) { fn := fun x => append ys { fn := fun x => zs } } }

tactic: apply ih
state_before: case mk.eq
α : Type u_1
xs ys zs : LazyList α
fn✝ : Unit → LazyList α
ih :
  ∀ (a : Unit),
    append (append (fn✝ a) { fn := fun x => ys }) { fn := fun x => zs } =
      append (fn✝ a) { fn := fun x => append ys { fn := fun x => zs } }
⊢ Thunk.get
      {
        fn := fun x =>
          append (Thunk.get { fn := fun x => append (Thunk.get { fn := fn✝ }) { fn := fun x => ys } })
            { fn := fun x => zs } } =
    Thunk.get { fn := fun x => append (Thunk.get { fn := fn✝ }) { fn := fun x => append ys { fn := fun x => zs } } }
Theorem: EMetric.infEdist_closure_pos_iff_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infEdist_closure, infEdist_pos_iff_not_mem_closure]
state_before: ι : Sort ?u.18028
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
⊢ 0 < infEdist x (closure E) ↔ ¬x ∈ closure E
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_integral_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds]
state_before: Ω : Type u_2
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), ↑f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), ↑f ω ∂↑μ))

tactic: rw [FiniteMeasure.tendsto_iff_forall_integral_tendsto]
state_before: Ω : Type u_2
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 (toFiniteMeasure μ)) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), ↑f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), ↑f ω ∂↑μ))

tactic: rfl
state_before: Ω : Type u_2
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ),
      Tendsto (fun i => ∫ (x : Ω), ↑f x ∂↑((toFiniteMeasure ∘ μs) i)) F (𝓝 (∫ (x : Ω), ↑f x ∂↑(toFiniteMeasure μ)))) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), ↑f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), ↑f ω ∂↑μ))
Theorem: Int.natAbs_eq_iff_sq_eq
File: Mathlib/Data/Int/Lemmas.lean

tactic: rw [sq, sq]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a = natAbs b ↔ a ^ 2 = b ^ 2

tactic: exact natAbs_eq_iff_mul_self_eq
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a = natAbs b ↔ a * a = b * b
Theorem: Multiset.Ico_inter_Ico
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, Ico, Ico, ← Finset.inter_val, Finset.Ico_inter_Ico]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a b c d : α
⊢ Ico a b ∩ Ico c d = Ico (max a c) (min b d)