ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.Kernel.fst_apply'
theorem fst_apply' (κ : Kernel α (β × γ)) (a : α) {s : Set β} (hs : MeasurableSet s) :
    fst κ a s = κ a {p | p.1 ∈ s} 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (a : α) {s : Set β} (hs : MeasurableSet s)
Goal: (κ.fst a) s = (κ a) {p | p.1 ∈ s}
-- ProbabilityTheory.Kernel.fst_zero
@[simp]
lemma fst_zero : fst (0 : Kernel α (β × γ)) = 0 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ}
Goal: ProbabilityTheory.Kernel.fst 0 = 0
-- ProbabilityTheory.Kernel.lintegral_fst
theorem lintegral_fst (κ : Kernel α (β × γ)) (a : α) {g : β → ℝ≥0∞} (hg : Measurable g) :
    ∫⁻ c, g c ∂fst κ a = ∫⁻ bc : β × γ, g bc.fst ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (a : α) {g : β → ℝ≥0∞} (hg : Measurable g)
Goal: ∫⁻ (c : β), g c ∂κ.fst a = ∫⁻ (bc : β × γ), g bc.1 ∂κ a
-- ProbabilityTheory.Kernel.fst_map_prod
lemma fst_map_prod (κ : Kernel α β) {f : β → γ} {g : β → δ}
    (hf : Measurable f) (hg : Measurable g) :
    fst (map κ (fun x ↦ (f x, g x)) (hf.prod_mk hg)) = map κ f hf 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {δ : Type u_4} {mδ : MeasurableSpace δ} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} {g : β → δ} (hf : Measurable f) (hg : Measurable g)
Goal: (κ.map (fun x => (f x, g x)) ⋯).fst = κ.map f hf
-- ProbabilityTheory.Kernel.fst_map_id_prod
lemma fst_map_id_prod (κ : Kernel α β) {γ : Type*} {mγ : MeasurableSpace γ}
    {f : β → γ} (hf : Measurable f) :
    fst (map κ (fun a ↦ (a, f a)) (measurable_id.prod_mk hf)) = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β) {γ : Type u_6} {mγ : MeasurableSpace γ} {f : β → γ} (hf : Measurable f)
Goal: (κ.map (fun a => (a, f a)) ⋯).fst = κ
-- ProbabilityTheory.Kernel.fst_compProd
@[simp]
lemma fst_compProd (κ : Kernel α β) (η : Kernel (α × β) γ) [IsSFiniteKernel κ] [IsMarkovKernel η] :
    fst (κ ⊗ₖ η) = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ) [ProbabilityTheory.IsSFiniteKernel κ] [ProbabilityTheory.IsMarkovKernel η]
Goal: (κ.compProd η).fst = κ
-- ProbabilityTheory.Kernel.fst_prodMkLeft
lemma fst_prodMkLeft (δ : Type*) [MeasurableSpace δ] (κ : Kernel α (β × γ)) :
    fst (prodMkLeft δ κ) = prodMkLeft δ (fst κ) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (δ : Type u_6) [MeasurableSpace δ] (κ : ProbabilityTheory.Kernel α (β × γ))
Goal: (ProbabilityTheory.Kernel.prodMkLeft δ κ).fst = ProbabilityTheory.Kernel.prodMkLeft δ κ.fst
-- ProbabilityTheory.Kernel.fst_prodMkRight
lemma fst_prodMkRight (κ : Kernel α (β × γ)) (δ : Type*) [MeasurableSpace δ] :
    fst (prodMkRight δ κ) = prodMkRight δ (fst κ) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (δ : Type u_6) [MeasurableSpace δ]
Goal: (ProbabilityTheory.Kernel.prodMkRight δ κ).fst = ProbabilityTheory.Kernel.prodMkRight δ κ.fst
-- ProbabilityTheory.Kernel.snd_apply
theorem snd_apply (κ : Kernel α (β × γ)) (a : α) : snd κ a = (κ a).map Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (a : α)
Goal: κ.snd a = MeasureTheory.Measure.map Prod.snd (κ a)
-- ProbabilityTheory.Kernel.snd_apply'
theorem snd_apply' (κ : Kernel α (β × γ)) (a : α) {s : Set γ} (hs : MeasurableSet s) :
    snd κ a s = κ a {p | p.2 ∈ s} 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (a : α) {s : Set γ} (hs : MeasurableSet s)
Goal: (κ.snd a) s = (κ a) {p | p.2 ∈ s}
-- ProbabilityTheory.Kernel.snd_zero
@[simp]
lemma snd_zero : snd (0 : Kernel α (β × γ)) = 0 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ}
Goal: ProbabilityTheory.Kernel.snd 0 = 0
-- ProbabilityTheory.Kernel.lintegral_snd
theorem lintegral_snd (κ : Kernel α (β × γ)) (a : α) {g : γ → ℝ≥0∞} (hg : Measurable g) :
    ∫⁻ c, g c ∂snd κ a = ∫⁻ bc : β × γ, g bc.snd ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (a : α) {g : γ → ℝ≥0∞} (hg : Measurable g)
Goal: ∫⁻ (c : γ), g c ∂κ.snd a = ∫⁻ (bc : β × γ), g bc.2 ∂κ a
-- ProbabilityTheory.Kernel.snd_map_prod
lemma snd_map_prod (κ : Kernel α β) {f : β → γ} {g : β → δ}
    (hf : Measurable f) (hg : Measurable g) :
    snd (map κ (fun x ↦ (f x, g x)) (hf.prod_mk hg)) = map κ g hg 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {δ : Type u_4} {mδ : MeasurableSpace δ} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} {g : β → δ} (hf : Measurable f) (hg : Measurable g)
Goal: (κ.map (fun x => (f x, g x)) ⋯).snd = κ.map g hg
-- ProbabilityTheory.Kernel.snd_map_prod_id
lemma snd_map_prod_id (κ : Kernel α β) {γ : Type*} {mγ : MeasurableSpace γ}
    {f : β → γ} (hf : Measurable f) :
    snd (map κ (fun a ↦ (f a, a)) (hf.prod_mk measurable_id)) = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β) {γ : Type u_6} {mγ : MeasurableSpace γ} {f : β → γ} (hf : Measurable f)
Goal: (κ.map (fun a => (f a, a)) ⋯).snd = κ
-- ProbabilityTheory.Kernel.snd_prodMkLeft
lemma snd_prodMkLeft (δ : Type*) [MeasurableSpace δ] (κ : Kernel α (β × γ)) :
    snd (prodMkLeft δ κ) = prodMkLeft δ (snd κ) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (δ : Type u_6) [MeasurableSpace δ] (κ : ProbabilityTheory.Kernel α (β × γ))
Goal: (ProbabilityTheory.Kernel.prodMkLeft δ κ).snd = ProbabilityTheory.Kernel.prodMkLeft δ κ.snd
-- ProbabilityTheory.Kernel.snd_prodMkRight
lemma snd_prodMkRight (κ : Kernel α (β × γ)) (δ : Type*) [MeasurableSpace δ] :
    snd (prodMkRight δ κ) = prodMkRight δ (snd κ) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) (δ : Type u_6) [MeasurableSpace δ]
Goal: (ProbabilityTheory.Kernel.prodMkRight δ κ).snd = ProbabilityTheory.Kernel.prodMkRight δ κ.snd
-- ProbabilityTheory.Kernel.fst_swapRight
@[simp]
lemma fst_swapRight (κ : Kernel α (β × γ)) : fst (swapRight κ) = snd κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ))
Goal: κ.swapRight.fst = κ.snd
-- ProbabilityTheory.Kernel.snd_swapRight
@[simp]
lemma snd_swapRight (κ : Kernel α (β × γ)) : snd (swapRight κ) = fst κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_5} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ))
Goal: κ.swapRight.snd = κ.fst
-- ProbabilityTheory.Kernel.comp_apply
theorem comp_apply (η : Kernel β γ) (κ : Kernel α β) (a : α) : (η ∘ₖ κ) a = (κ a).bind η 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) (κ : ProbabilityTheory.Kernel α β) (a : α)
Goal: (η.comp κ) a = (κ a).bind ⇑η
-- ProbabilityTheory.Kernel.comp_apply'
theorem comp_apply' (η : Kernel β γ) (κ : Kernel α β) (a : α) {s : Set γ} (hs : MeasurableSet s) :
    (η ∘ₖ κ) a s = ∫⁻ b, η b s ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) (κ : ProbabilityTheory.Kernel α β) (a : α) {s : Set γ} (hs : MeasurableSet s)
Goal: ((η.comp κ) a) s = ∫⁻ (b : β), (η b) s ∂κ a
-- ProbabilityTheory.Kernel.comp_eq_snd_compProd
theorem comp_eq_snd_compProd (η : Kernel β γ) [IsSFiniteKernel η] (κ : Kernel α β)
    [IsSFiniteKernel κ] : η ∘ₖ κ = snd (κ ⊗ₖ prodMkLeft α η) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) [ProbabilityTheory.IsSFiniteKernel η] (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ]
Goal: η.comp κ = (κ.compProd (ProbabilityTheory.Kernel.prodMkLeft α η)).snd
-- ProbabilityTheory.Kernel.lintegral_comp
theorem lintegral_comp (η : Kernel β γ) (κ : Kernel α β) (a : α) {g : γ → ℝ≥0∞}
    (hg : Measurable g) : ∫⁻ c, g c ∂(η ∘ₖ κ) a = ∫⁻ b, ∫⁻ c, g c ∂η b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) (κ : ProbabilityTheory.Kernel α β) (a : α) {g : γ → ℝ≥0∞} (hg : Measurable g)
Goal: ∫⁻ (c : γ), g c ∂(η.comp κ) a = ∫⁻ (b : β), ∫⁻ (c : γ), g c ∂η b ∂κ a
-- ProbabilityTheory.Kernel.comp_assoc
theorem comp_assoc {δ : Type*} {mδ : MeasurableSpace δ} (ξ : Kernel γ δ) [IsSFiniteKernel ξ]
    (η : Kernel β γ) (κ : Kernel α β) : ξ ∘ₖ η ∘ₖ κ = ξ ∘ₖ (η ∘ₖ κ) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {δ : Type u_5} {mδ : MeasurableSpace δ} (ξ : ProbabilityTheory.Kernel γ δ) [ProbabilityTheory.IsSFiniteKernel ξ] (η : ProbabilityTheory.Kernel β γ) (κ : ProbabilityTheory.Kernel α β)
Goal: (ξ.comp η).comp κ = ξ.comp (η.comp κ)
-- ProbabilityTheory.Kernel.deterministic_comp_eq_map
theorem deterministic_comp_eq_map (hf : Measurable f) (κ : Kernel α β) :
    deterministic f hf ∘ₖ κ = map κ f hf 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (hf : Measurable f) (κ : ProbabilityTheory.Kernel α β)
Goal: (ProbabilityTheory.Kernel.deterministic f hf).comp κ = κ.map f hf
-- ProbabilityTheory.Kernel.comp_deterministic_eq_comap
theorem comp_deterministic_eq_comap (κ : Kernel α β) (hg : Measurable g) :
    κ ∘ₖ deterministic g hg = comap κ g hg 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {g : γ → α} (κ : ProbabilityTheory.Kernel α β) (hg : Measurable g)
Goal: κ.comp (ProbabilityTheory.Kernel.deterministic g hg) = κ.comap g hg
-- ProbabilityTheory.Kernel.prod_apply'
theorem prod_apply' (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsSFiniteKernel η]
    (a : α) {s : Set (β × γ)} (hs : MeasurableSet s) :
    (κ ×ₖ η) a s = ∫⁻ b : β, (η a) {c : γ | (b, c) ∈ s} ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η] (a : α) {s : Set (β × γ)} (hs : MeasurableSet s)
Goal: ((κ.prod η) a) s = ∫⁻ (b : β), (η a) {c | (b, c) ∈ s} ∂κ a
-- ProbabilityTheory.Kernel.prod_apply
lemma prod_apply (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsSFiniteKernel η]
    (a : α) :
    (κ ×ₖ η) a = (κ a).prod (η a) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η] (a : α)
Goal: (κ.prod η) a = (κ a).prod (η a)
-- ProbabilityTheory.Kernel.prod_const
lemma prod_const (μ : Measure β) [SFinite μ] (ν : Measure γ) [SFinite ν] :
    const α μ ×ₖ const α ν = const α (μ.prod ν) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (μ : MeasureTheory.Measure β) [MeasureTheory.SFinite μ] (ν : MeasureTheory.Measure γ) [MeasureTheory.SFinite ν]
Goal: (ProbabilityTheory.Kernel.const α μ).prod (ProbabilityTheory.Kernel.const α ν) =
  ProbabilityTheory.Kernel.const α (μ.prod ν)
-- ProbabilityTheory.Kernel.lintegral_prod
theorem lintegral_prod (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsSFiniteKernel η]
    (a : α) {g : β × γ → ℝ≥0∞} (hg : Measurable g) :
    ∫⁻ c, g c ∂(κ ×ₖ η) a = ∫⁻ b, ∫⁻ c, g (b, c) ∂η a ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η] (a : α) {g : β × γ → ℝ≥0∞} (hg : Measurable g)
Goal: ∫⁻ (c : β × γ), g c ∂(κ.prod η) a = ∫⁻ (b : β), ∫⁻ (c : γ), g (b, c) ∂η a ∂κ a
-- ProbabilityTheory.Kernel.fst_prod
@[simp] lemma fst_prod (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsMarkovKernel η] :
    fst (κ ×ₖ η) = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsMarkovKernel η]
Goal: (κ.prod η).fst = κ
-- ProbabilityTheory.Kernel.snd_prod
@[simp] lemma snd_prod (κ : Kernel α β) [IsMarkovKernel κ] (η : Kernel α γ) [IsSFiniteKernel η] :
    snd (κ ×ₖ η) = η 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η]
Goal: (κ.prod η).snd = η
-- scaleRoots_aeval_eq_zero_of_aeval_mk'_eq_zero
theorem scaleRoots_aeval_eq_zero_of_aeval_mk'_eq_zero {p : A[X]} {r : A} {s : M}
    (hr : aeval (mk' S r s) p = 0) : aeval (algebraMap A S r) (scaleRoots p s) = 0 
Arguments: {A : Type u_1} {S : Type u_4} [CommRing A] [CommRing S] {M : Submonoid A} [Algebra A S] [IsLocalization M S] {p : A[X]} {r : A} {s : ↥M} (hr : (Polynomial.aeval (IsLocalization.mk' S r s)) p = 0)
Goal: (Polynomial.aeval ((algebraMap A S) r)) (p.scaleRoots ↑s) = 0
-- num_isRoot_scaleRoots_of_aeval_eq_zero
theorem num_isRoot_scaleRoots_of_aeval_eq_zero [UniqueFactorizationMonoid A] {p : A[X]} {x : K}
    (hr : aeval x p = 0) : IsRoot (scaleRoots p (den A x)) (num A x) 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [Field K] [Algebra A K] [IsFractionRing A K] [IsDomain A] [UniqueFactorizationMonoid A] {p : A[X]} {x : K} (hr : (Polynomial.aeval x) p = 0)
Goal: (p.scaleRoots ↑(IsFractionRing.den A x)).IsRoot (IsFractionRing.num A x)
-- num_dvd_of_is_root
theorem num_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) : num A r ∣ p.coeff 0 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [Field K] [Algebra A K] [IsFractionRing A K] {p : A[X]} {r : K} (hr : (Polynomial.aeval r) p = 0)
Goal: IsFractionRing.num A r ∣ p.coeff 0
-- den_dvd_of_is_root
theorem den_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) :
    (den A r : A) ∣ p.leadingCoeff 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [Field K] [Algebra A K] [IsFractionRing A K] {p : A[X]} {r : K} (hr : (Polynomial.aeval r) p = 0)
Goal: ↑(IsFractionRing.den A r) ∣ p.leadingCoeff
-- isInteger_of_is_root_of_monic
theorem isInteger_of_is_root_of_monic {p : A[X]} (hp : Monic p) {r : K} (hr : aeval r p = 0) :
    IsInteger A r 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [Field K] [Algebra A K] [IsFractionRing A K] {p : A[X]} (hp : p.Monic) {r : K} (hr : (Polynomial.aeval r) p = 0)
Goal: IsLocalization.IsInteger A r
-- exists_integer_of_is_root_of_monic
theorem exists_integer_of_is_root_of_monic {p : A[X]} (hp : Monic p) {r : K} (hr : aeval r p = 0) :
    ∃ r' : A, r = algebraMap A K r' ∧ r' ∣ p.coeff 0 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [Field K] [Algebra A K] [IsFractionRing A K] {p : A[X]} (hp : p.Monic) {r : K} (hr : (Polynomial.aeval r) p = 0)
Goal: ∃ r', r = (algebraMap A K) r' ∧ r' ∣ p.coeff 0
-- UniqueFactorizationMonoid.integer_of_integral
theorem integer_of_integral {x : K} : IsIntegral A x → IsInteger A x 
Arguments: {A : Type u_1} {K : Type u_2} [CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [Field K] [Algebra A K] [IsFractionRing A K] {x : K}
Goal: IsIntegral A x → IsLocalization.IsInteger A x
-- Polynomial.HasSeparableContraction.isSeparableContraction
theorem HasSeparableContraction.isSeparableContraction :
    IsSeparableContraction q f hf.contraction 
Arguments: {F : Type u_1} [CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f)
Goal: Polynomial.IsSeparableContraction q f hf.contraction
-- Polynomial.IsSeparableContraction.dvd_degree'
theorem IsSeparableContraction.dvd_degree' {g} (hf : IsSeparableContraction q f g) :
    ∃ m : ℕ, g.natDegree * q ^ m = f.natDegree 
Arguments: {F : Type u_1} [CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f) {g : Polynomial F}
Goal: Polynomial.IsSeparableContraction q f g → ∃ m, g.natDegree * q ^ m = f.natDegree
-- Polynomial.HasSeparableContraction.dvd_degree'
theorem HasSeparableContraction.dvd_degree' : ∃ m : ℕ, hf.degree * q ^ m = f.natDegree 
Arguments: {F : Type u_1} [CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f)
Goal: ∃ m, hf.degree * q ^ m = f.natDegree
-- Polynomial.HasSeparableContraction.dvd_degree
theorem HasSeparableContraction.dvd_degree : hf.degree ∣ f.natDegree 
Arguments: {F : Type u_1} [CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f)
Goal: hf.degree ∣ f.natDegree
-- Polynomial.HasSeparableContraction.eq_degree
theorem HasSeparableContraction.eq_degree {f : F[X]} (hf : HasSeparableContraction 1 f) :
    hf.degree = f.natDegree 
Arguments: {F : Type u_1} [CommSemiring F] {f : Polynomial F} (hf : Polynomial.HasSeparableContraction 1 f)
Goal: hf.degree = f.natDegree
-- Irreducible.hasSeparableContraction
theorem _root_.Irreducible.hasSeparableContraction (q : ℕ) [hF : ExpChar F q] {f : F[X]}
    (irred : Irreducible f) : HasSeparableContraction q f 
Arguments: {F : Type u_1} [Field F] (q : ℕ) [hF : ExpChar F q] {f : Polynomial F} (irred : Irreducible f)
Goal: Polynomial.HasSeparableContraction q f
-- Polynomial.contraction_degree_eq_or_insep
theorem contraction_degree_eq_or_insep [hq : NeZero q] [CharP F q] (g g' : F[X]) (m m' : ℕ)
    (h_expand : expand F (q ^ m) g = expand F (q ^ m') g') (hg : g.Separable) (hg' : g'.Separable) :
    g.natDegree = g'.natDegree 
Arguments: {F : Type u_1} [Field F] (q : ℕ) [hq : NeZero q] [CharP F q] (g g' : Polynomial F) (m m' : ℕ) (h_expand : (Polynomial.expand F (q ^ m)) g = (Polynomial.expand F (q ^ m')) g') (hg : g.Separable) (hg' : g'.Separable)
Goal: g.natDegree = g'.natDegree
-- Polynomial.IsSeparableContraction.degree_eq
theorem IsSeparableContraction.degree_eq [hF : ExpChar F q] (g : F[X])
    (hg : IsSeparableContraction q f g) : g.natDegree = hf.degree 
Arguments: {F : Type u_1} [Field F] (q : ℕ) {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f) [hF : ExpChar F q] (g : Polynomial F) (hg : Polynomial.IsSeparableContraction q f g)
Goal: g.natDegree = hf.degree
-- Polynomial.dickson_zero
@[simp]
theorem dickson_zero : dickson k a 0 = 3 - k 
Arguments: {R : Type u_1} [CommRing R] (k : ℕ) (a : R)
Goal: Polynomial.dickson k a 0 = 3 - ↑k
-- Polynomial.dickson_one
@[simp]
theorem dickson_one : dickson k a 1 = X 
Arguments: {R : Type u_1} [CommRing R] (k : ℕ) (a : R)
Goal: Polynomial.dickson k a 1 = Polynomial.X
-- Polynomial.dickson_two
theorem dickson_two : dickson k a 2 = X ^ 2 - C a * (3 - k : R[X]) 
Arguments: {R : Type u_1} [CommRing R] (k : ℕ) (a : R)
Goal: Polynomial.dickson k a 2 = Polynomial.X ^ 2 - Polynomial.C a * (3 - ↑k)
-- Polynomial.dickson_add_two
@[simp]
theorem dickson_add_two (n : ℕ) :
    dickson k a (n + 2) = X * dickson k a (n + 1) - C a * dickson k a n 
Arguments: {R : Type u_1} [CommRing R] (k : ℕ) (a : R) (n : ℕ)
Goal: Polynomial.dickson k a (n + 2) =
  Polynomial.X * Polynomial.dickson k a (n + 1) - Polynomial.C a * Polynomial.dickson k a n
-- Polynomial.dickson_of_two_le
theorem dickson_of_two_le {n : ℕ} (h : 2 ≤ n) :
    dickson k a n = X * dickson k a (n - 1) - C a * dickson k a (n - 2) 
Arguments: {R : Type u_1} [CommRing R] (k : ℕ) (a : R) {n : ℕ} (h : 2 ≤ n)
Goal: Polynomial.dickson k a n =
  Polynomial.X * Polynomial.dickson k a (n - 1) - Polynomial.C a * Polynomial.dickson k a (n - 2)
-- Polynomial.map_dickson
theorem map_dickson (f : R →+* S) : ∀ n : ℕ, map f (dickson k a n) = dickson k (f a) n
  
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] {k : ℕ} {a : R} (f : R →+* S) (n : ℕ)
Goal: Polynomial.map f (Polynomial.dickson k a n) = Polynomial.dickson k (f a) n
-- Polynomial.dickson_two_zero
@[simp]
theorem dickson_two_zero : ∀ n : ℕ, dickson 2 (0 : R) n = X ^ n
  
Arguments: {R : Type u_1} [CommRing R] (n : ℕ)
Goal: Polynomial.dickson 2 0 n = Polynomial.X ^ n
-- Polynomial.dickson_one_one_eval_add_inv
theorem dickson_one_one_eval_add_inv (x y : R) (h : x * y = 1) :
    ∀ n, (dickson 1 (1 : R) n).eval (x + y) = x ^ n + y ^ n
  
Arguments: {R : Type u_1} [CommRing R] (x y : R) (h : x * y = 1) (n : ℕ)
Goal: Polynomial.eval (x + y) (Polynomial.dickson 1 1 n) = x ^ n + y ^ n
-- _private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.two_mul_C_half_eq_one
private theorem two_mul_C_half_eq_one [Invertible (2 : R)] : 2 * C (⅟ 2 : R) = 1 
Arguments: (R : Type u_1) [CommRing R] [Invertible 2]
Goal: 2 * Polynomial.C ⅟2 = 1
-- _private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.C_half_mul_two_eq_one
private theorem C_half_mul_two_eq_one [Invertible (2 : R)] : C (⅟ 2 : R) * 2 = 1 
Arguments: (R : Type u_1) [CommRing R] [Invertible 2]
Goal: Polynomial.C ⅟2 * 2 = 1
-- Polynomial.dickson_one_one_eq_chebyshev_T
theorem dickson_one_one_eq_chebyshev_T [Invertible (2 : R)] :
    ∀ n, dickson 1 (1 : R) n = 2 * (Chebyshev.T R n).comp (C (⅟ 2) * X)
  
Arguments: (R : Type u_1) [CommRing R] [Invertible 2] (n : ℕ)
Goal: Polynomial.dickson 1 1 n = 2 * (Polynomial.Chebyshev.T R ↑n).comp (Polynomial.C ⅟2 * Polynomial.X)
-- Polynomial.chebyshev_T_eq_dickson_one_one
theorem chebyshev_T_eq_dickson_one_one [Invertible (2 : R)] (n : ℕ) :
    Chebyshev.T R n = C (⅟ 2) * (dickson 1 1 n).comp (2 * X) 
Arguments: (R : Type u_1) [CommRing R] [Invertible 2] (n : ℕ)
Goal: Polynomial.Chebyshev.T R ↑n = Polynomial.C ⅟2 * (Polynomial.dickson 1 1 n).comp (2 * Polynomial.X)
-- Polynomial.dickson_one_one_mul
theorem dickson_one_one_mul (m n : ℕ) :
    dickson 1 (1 : R) (m * n) = (dickson 1 1 m).comp (dickson 1 1 n) 
Arguments: (R : Type u_1) [CommRing R] (m n : ℕ)
Goal: Polynomial.dickson 1 1 (m * n) = (Polynomial.dickson 1 1 m).comp (Polynomial.dickson 1 1 n)
-- Polynomial.dickson_one_one_comp_comm
theorem dickson_one_one_comp_comm (m n : ℕ) :
    (dickson 1 (1 : R) m).comp (dickson 1 1 n) = (dickson 1 1 n).comp (dickson 1 1 m) 
Arguments: (R : Type u_1) [CommRing R] (m n : ℕ)
Goal: (Polynomial.dickson 1 1 m).comp (Polynomial.dickson 1 1 n) = (Polynomial.dickson 1 1 n).comp (Polynomial.dickson 1 1 m)
-- Polynomial.dickson_one_one_zmod_p
theorem dickson_one_one_zmod_p (p : ℕ) [Fact p.Prime] : dickson 1 (1 : ZMod p) p = X ^ p 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: Polynomial.dickson 1 1 p = Polynomial.X ^ p