ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_univ_of_monotone
lemma tendsto_densityProcess_fst_atTop_univ_of_monotone (κ : Kernel α (γ × β)) (n : ℕ) (a : α)
    (x : γ) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ) :
    Tendsto (fun m ↦ densityProcess κ (fst κ) n a x (seq m)) atTop
      (𝓝 (densityProcess κ (fst κ) n a x univ)) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β)) (n : ℕ) (a : α) (x : γ) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = Set.univ)
Goal: Filter.Tendsto (fun m => κ.densityProcess κ.fst n a x (seq m)) Filter.atTop (𝓝 (κ.densityProcess κ.fst n a x Set.univ))
-- ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_ae_of_monotone
lemma tendsto_densityProcess_fst_atTop_ae_of_monotone (κ : Kernel α (γ × β)) [IsFiniteKernel κ]
    (n : ℕ) (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ) :
    ∀ᵐ x ∂(fst κ a), Tendsto (fun m ↦ densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 1) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β)) [ProbabilityTheory.IsFiniteKernel κ] (n : ℕ) (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = Set.univ)
Goal: ∀ᵐ (x : γ) ∂κ.fst a, Filter.Tendsto (fun m => κ.densityProcess κ.fst n a x (seq m)) Filter.atTop (𝓝 1)
-- ProbabilityTheory.Kernel.density_fst_univ
lemma density_fst_univ (κ : Kernel α (γ × β)) [IsFiniteKernel κ] (a : α) :
    ∀ᵐ x ∂(fst κ a), density κ (fst κ) a x univ = 1 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β)) [ProbabilityTheory.IsFiniteKernel κ] (a : α)
Goal: ∀ᵐ (x : γ) ∂κ.fst a, κ.density κ.fst a x Set.univ = 1
-- ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone
lemma tendsto_density_fst_atTop_ae_of_monotone [IsFiniteKernel κ]
    (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    ∀ᵐ x ∂(fst κ a), Tendsto (fun m ↦ density κ (fst κ) a x (seq m)) atTop (𝓝 1) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)} [ProbabilityTheory.IsFiniteKernel κ] (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = Set.univ) (hseq_meas : ∀ (m : ℕ), MeasurableSet (seq m))
Goal: ∀ᵐ (x : γ) ∂κ.fst a, Filter.Tendsto (fun m => κ.density κ.fst a x (seq m)) Filter.atTop (𝓝 1)
-- Polynomial.deriv_gaussian_eq_hermite_mul_gaussian
theorem deriv_gaussian_eq_hermite_mul_gaussian (n : ℕ) (x : ℝ) :
    deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x =
    (-1 : ℝ) ^ n * aeval x (hermite n) * Real.exp (-(x ^ 2 / 2)) 
Arguments: (n : ℕ) (x : ℝ)
Goal: deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x =
  (-1) ^ n * (Polynomial.aeval x) (Polynomial.hermite n) * Real.exp (-(x ^ 2 / 2))
-- Polynomial.hermite_eq_deriv_gaussian
theorem hermite_eq_deriv_gaussian (n : ℕ) (x : ℝ) : aeval x (hermite n) =
    (-1 : ℝ) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / Real.exp (-(x ^ 2 / 2)) 
Arguments: (n : ℕ) (x : ℝ)
Goal: (Polynomial.aeval x) (Polynomial.hermite n) =
  (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / Real.exp (-(x ^ 2 / 2))
-- Polynomial.hermite_eq_deriv_gaussian'
theorem hermite_eq_deriv_gaussian' (n : ℕ) (x : ℝ) : aeval x (hermite n) =
    (-1 : ℝ) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2) 
Arguments: (n : ℕ) (x : ℝ)
Goal: (Polynomial.aeval x) (Polynomial.hermite n) =
  (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2)
-- _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.LinearMap.reduceModIdealAux_apply
@[local simp]
private theorem reduceModIdealAux_apply (f : M →ₗ[R] N) (x : M) :
    (f.reduceModIdealAux I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) (x : M)
Goal: (LinearMap.reduceModIdealAux I f) (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)
-- LinearMap.reduceModIdeal_apply
@[simp]
theorem reduceModIdeal_apply (f : M →ₗ[R] N) (x : M) :
    (f.reduceModIdeal I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) (x : M)
Goal: (LinearMap.reduceModIdeal I f) (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)
-- AdicCompletion.transitionMap_comp_reduceModIdeal
theorem transitionMap_comp_reduceModIdeal (f : M →ₗ[R] N) {m n : ℕ}
    (hmn : m ≤ n) : transitionMap I N hmn ∘ₗ f.reduceModIdeal (I ^ n) =
      (f.reduceModIdeal (I ^ m) : _ →ₗ[R] _) ∘ₗ transitionMap I M hmn 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) {m n : ℕ} (hmn : m ≤ n)
Goal: AdicCompletion.transitionMap I N hmn ∘ₗ ↑R (LinearMap.reduceModIdeal (I ^ n) f) =
  ↑R (LinearMap.reduceModIdeal (I ^ m) f) ∘ₗ AdicCompletion.transitionMap I M hmn
-- AdicCompletion.AdicCauchySequence.map_apply_coe
@[simps]
def map (f : M →ₗ[R] N) : AdicCauchySequence I M →ₗ[R] AdicCauchySequence I N 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) (a : AdicCompletion.AdicCauchySequence I M) (n : ℕ)
Goal: ↑((AdicCompletion.AdicCauchySequence.map I f) a) n = f (↑a n)
-- AdicCompletion.AdicCauchySequence.map_id
@[simp]
theorem map_id : map I (LinearMap.id (M := M)) = LinearMap.id 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (M : Type u_2) [AddCommGroup M] [Module R M]
Goal: AdicCompletion.AdicCauchySequence.map I LinearMap.id = LinearMap.id
-- AdicCompletion.AdicCauchySequence.map_comp
theorem map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
    map I g ∘ₗ map I f = map I (g ∘ₗ f) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P)
Goal: AdicCompletion.AdicCauchySequence.map I g ∘ₗ AdicCompletion.AdicCauchySequence.map I f =
  AdicCompletion.AdicCauchySequence.map I (g ∘ₗ f)
-- AdicCompletion.AdicCauchySequence.map_comp_apply
theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (a : AdicCauchySequence I M) :
    map I g (map I f a) = map I (g ∘ₗ f) a 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) (a : AdicCompletion.AdicCauchySequence I M)
Goal: (AdicCompletion.AdicCauchySequence.map I g) ((AdicCompletion.AdicCauchySequence.map I f) a) =
  (AdicCompletion.AdicCauchySequence.map I (g ∘ₗ f)) a
-- AdicCompletion.AdicCauchySequence.map_zero
@[simp]
theorem map_zero : map I (0 : M →ₗ[R] N) = 0 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N]
Goal: AdicCompletion.AdicCauchySequence.map I 0 = 0
-- _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.AdicCompletion.adicCompletionAux_val_apply
@[local simp]
private theorem adicCompletionAux_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
    (adicCompletionAux I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M)
Goal: ↑((AdicCompletion.adicCompletionAux I f) x) n = (LinearMap.reduceModIdeal (I ^ n) f) (↑x n)
-- AdicCompletion.map_val_apply
@[simp]
theorem map_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
    (map I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M)
Goal: ↑((AdicCompletion.map I f) x) n = (LinearMap.reduceModIdeal (I ^ n) f) (↑x n)
-- AdicCompletion.map_ext
theorem map_ext {f g : AdicCompletion I M → N}
    (h : ∀ (a : AdicCauchySequence I M),
      f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
    f = g 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} {f g : AdicCompletion I M → N} (h : ∀ (a : AdicCompletion.AdicCauchySequence I M), f ((AdicCompletion.mk I M) a) = g ((AdicCompletion.mk I M) a))
Goal: f = g
-- AdicCompletion.map_ext'
@[ext]
theorem map_ext' {f g : AdicCompletion I M →ₗ[AdicCompletion I R] T}
    (h : ∀ (a : AdicCauchySequence I M),
      f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
    f = g 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {T : Type u_5} [AddCommGroup T] [Module (AdicCompletion I R) T] {f g : AdicCompletion I M →ₗ[AdicCompletion I R] T} (h : ∀ (a : AdicCompletion.AdicCauchySequence I M), f ((AdicCompletion.mk I M) a) = g ((AdicCompletion.mk I M) a))
Goal: f = g
-- AdicCompletion.map_ext''
@[ext]
theorem map_ext'' {f g : AdicCompletion I M →ₗ[R] N}
    (h : f.comp (AdicCompletion.mk I M) = g.comp (AdicCompletion.mk I M)) :
    f = g 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {f g : AdicCompletion I M →ₗ[R] N} (h : f ∘ₗ AdicCompletion.mk I M = g ∘ₗ AdicCompletion.mk I M)
Goal: f = g
-- AdicCompletion.map_id
@[simp]
theorem map_id :
    map I (LinearMap.id (M := M)) =
      LinearMap.id (R := AdicCompletion I R) (M := AdicCompletion I M) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (M : Type u_2) [AddCommGroup M] [Module R M]
Goal: AdicCompletion.map I LinearMap.id = LinearMap.id
-- AdicCompletion.map_comp
theorem map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
    map I g ∘ₗ map I f = map I (g ∘ₗ f) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P)
Goal: AdicCompletion.map I g ∘ₗ AdicCompletion.map I f = AdicCompletion.map I (g ∘ₗ f)
-- AdicCompletion.map_comp_apply
theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M) :
    map I g (map I f x) = map I (g ∘ₗ f) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M)
Goal: (AdicCompletion.map I g) ((AdicCompletion.map I f) x) = (AdicCompletion.map I (g ∘ₗ f)) x
-- AdicCompletion.map_mk
@[simp]
theorem map_mk (f : M →ₗ[R] N) (a : AdicCauchySequence I M) :
    map I f (AdicCompletion.mk I M a) =
      AdicCompletion.mk I N (AdicCauchySequence.map I f a) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) (a : AdicCompletion.AdicCauchySequence I M)
Goal: (AdicCompletion.map I f) ((AdicCompletion.mk I M) a) =
  (AdicCompletion.mk I N) ((AdicCompletion.AdicCauchySequence.map I f) a)
-- AdicCompletion.map_zero
@[simp]
theorem map_zero : map I (0 : M →ₗ[R] N) = 0 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N]
Goal: AdicCompletion.map I 0 = 0
-- AdicCompletion.congr_apply
@[simp]
theorem congr_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I M) :
    congr I f x = map I f x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M ≃ₗ[R] N) (x : AdicCompletion I M)
Goal: (AdicCompletion.congr I f) x = (AdicCompletion.map I ↑f) x
-- AdicCompletion.congr_symm_apply
@[simp]
theorem congr_symm_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I N) :
    (congr I f).symm x = map I f.symm x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M ≃ₗ[R] N) (x : AdicCompletion I N)
Goal: (AdicCompletion.congr I f).symm x = (AdicCompletion.map I ↑f.symm) x
-- AdicCompletion.pi_apply_coe
@[simps!]
def pi : AdicCompletion I (∀ j, M j) →ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] (c : AdicCompletion I ((j : ι) → M j)) (i : ι) (n : ℕ)
Goal: ↑((AdicCompletion.pi I M) c i) n = (LinearMap.reduceModIdeal (I ^ n) (LinearMap.proj i)) (↑c n)
-- AdicCompletion.sum_lof
@[simp]
theorem sum_lof (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.lof (AdicCompletion I R) ι (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] (j : ι) (x : AdicCompletion I (M j))
Goal: (AdicCompletion.sum I M) ((DirectSum.lof (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) x) =
  (AdicCompletion.map I (DirectSum.lof R ι M j)) x
-- AdicCompletion.sum_of
@[simp]
theorem sum_of (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.of (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] (j : ι) (x : AdicCompletion I (M j))
Goal: (AdicCompletion.sum I M) ((DirectSum.of (fun i => AdicCompletion I (M i)) j) x) =
  (AdicCompletion.map I (DirectSum.lof R ι M j)) x
-- AdicCompletion.component_sumInv
@[simp]
theorem component_sumInv (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
    component (AdicCompletion I R) ι _ j (sumInv I M x) =
      map I (component R ι _ j) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I (DirectSum ι fun j => M j)) (j : ι)
Goal: (DirectSum.component (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) ((AdicCompletion.sumInv I M) x) =
  (AdicCompletion.map I (DirectSum.component R ι M j)) x
-- AdicCompletion.sumInv_apply
@[simp]
theorem sumInv_apply (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
    (sumInv I M x) j = map I (component R ι _ j) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I (DirectSum ι fun j => M j)) (j : ι)
Goal: ((AdicCompletion.sumInv I M) x) j = (AdicCompletion.map I (DirectSum.component R ι M j)) x
-- AdicCompletion.sumInv_comp_sum
theorem sumInv_comp_sum : sumInv I M ∘ₗ sum I M = LinearMap.id 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι]
Goal: AdicCompletion.sumInv I M ∘ₗ AdicCompletion.sum I M = LinearMap.id
-- AdicCompletion.sum_comp_sumInv
theorem sum_comp_sumInv : sum I M ∘ₗ sumInv I M = LinearMap.id 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι]
Goal: AdicCompletion.sum I M ∘ₗ AdicCompletion.sumInv I M = LinearMap.id
-- AdicCompletion.sumEquivOfFintype_apply
@[simp]
theorem sumEquivOfFintype_apply (x : ⨁ j, (AdicCompletion I (M j))) :
    sumEquivOfFintype I M x = sum I M x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : DirectSum ι fun j => AdicCompletion I (M j))
Goal: (AdicCompletion.sumEquivOfFintype I M) x = (AdicCompletion.sum I M) x
-- AdicCompletion.sumEquivOfFintype_symm_apply
@[simp]
theorem sumEquivOfFintype_symm_apply (x : AdicCompletion I (⨁ j, M j)) :
    (sumEquivOfFintype I M).symm x = sumInv I M x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I (DirectSum ι fun j => M j))
Goal: (AdicCompletion.sumEquivOfFintype I M).symm x = (AdicCompletion.sumInv I M) x
-- AdicCompletion.piEquivOfFintype_apply
@[simp]
theorem piEquivOfFintype_apply (x : AdicCompletion I (∀ j, M j)) :
    piEquivOfFintype I M x = pi I M x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} [DecidableEq ι] (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I ((j : ι) → M j))
Goal: (AdicCompletion.piEquivOfFintype I M) x = (AdicCompletion.pi I M) x
-- AdicCompletion.piEquivFin_apply
@[simp]
theorem piEquivFin_apply (n : ℕ) (x : AdicCompletion I (Fin n → R)) :
    piEquivFin I n x = pi I (fun _ : Fin n ↦ R) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ) (x : AdicCompletion I (Fin n → R))
Goal: (AdicCompletion.piEquivFin I n) x = (AdicCompletion.pi I fun x => R) x
-- AdicCompletion.transitionMap_ideal_mk
@[local simp]
theorem transitionMap_ideal_mk {m n : ℕ} (hmn : m ≤ n) (x : R) :
    transitionMap I R hmn (Ideal.Quotient.mk (I ^ n • ⊤ : Ideal R) x) =
      Ideal.Quotient.mk (I ^ m • ⊤ : Ideal R) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {m n : ℕ} (hmn : m ≤ n) (x : R)
Goal: (AdicCompletion.transitionMap I R hmn) ((Ideal.Quotient.mk (I ^ n • ⊤)) x) = (Ideal.Quotient.mk (I ^ m • ⊤)) x
-- AdicCompletion.transitionMap_map_one
@[local simp]
theorem transitionMap_map_one {m n : ℕ} (hmn : m ≤ n) : transitionMap I R hmn 1 = 1 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {m n : ℕ} (hmn : m ≤ n)
Goal: (AdicCompletion.transitionMap I R hmn) 1 = 1
-- AdicCompletion.transitionMap_map_mul
@[local simp]
theorem transitionMap_map_mul {m n : ℕ} (hmn : m ≤ n) (x y : R ⧸ (I ^ n • ⊤ : Ideal R)) :
    transitionMap I R hmn (x * y) = transitionMap I R hmn x * transitionMap I R hmn y 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {m n : ℕ} (hmn : m ≤ n) (x : R ⧸ I ^ n • ⊤) (y : R ⧸ I ^ n • ⊤)
Goal: (AdicCompletion.transitionMap I R hmn) (x * y) =
  (AdicCompletion.transitionMap I R hmn) x * (AdicCompletion.transitionMap I R hmn) y
-- AdicCompletion.transitionMap_map_pow
@[local simp]
theorem transitionMap_map_pow {m n a : ℕ} (hmn : m ≤ n) (x : R ⧸ (I ^ n • ⊤ : Ideal R)) :
    transitionMap I R hmn (x ^ a) = transitionMap I R hmn x ^ a 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {m n a : ℕ} (hmn : m ≤ n) (x : R ⧸ I ^ n • ⊤)
Goal: (AdicCompletion.transitionMap I R hmn) (x ^ a) = (AdicCompletion.transitionMap I R hmn) x ^ a
-- AdicCompletion.val_one
@[simp]
theorem val_one (n : ℕ) : (1 : AdicCompletion I R).val n = 1 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ)
Goal: ↑1 n = 1
-- AdicCompletion.val_mul
@[simp]
theorem val_mul (n : ℕ) (x y : AdicCompletion I R) : (x * y).val n = x.val n * y.val n 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ) (x y : AdicCompletion I R)
Goal: ↑(x * y) n = ↑x n * ↑y n
-- AdicCompletion.evalₐ_mk
@[simp]
theorem evalₐ_mk (n : ℕ) (x : AdicCauchySequence I R) :
    evalₐ I n (mk I R x) = Ideal.Quotient.mk (I ^ n) (x.val n) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ) (x : AdicCompletion.AdicCauchySequence I R)
Goal: (AdicCompletion.evalₐ I n) ((AdicCompletion.mk I R) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n)
-- AdicCompletion.one_apply
@[simp]
theorem one_apply (n : ℕ) : (1 : AdicCauchySequence I R) n = 1 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ)
Goal: ↑1 n = 1
-- AdicCompletion.mul_apply
@[simp]
theorem mul_apply (n : ℕ) (f g : AdicCauchySequence I R) : (f * g) n = f n * g n 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ) (f g : AdicCompletion.AdicCauchySequence I R)
Goal: ↑(f * g) n = ↑f n * ↑g n
-- AdicCompletion.mkₐ_apply_coe
@[simps!]
def mkₐ : AdicCauchySequence I R →ₐ[R] AdicCompletion I R 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (a : AdicCompletion.AdicCauchySequence I R) (n : ℕ)
Goal: ↑((AdicCompletion.mkₐ I) a) n = (Ideal.Quotient.mk (I ^ n • ⊤)) (↑a n)
-- AdicCompletion.evalₐ_mkₐ
@[simp]
theorem evalₐ_mkₐ (n : ℕ) (x : AdicCauchySequence I R) :
    evalₐ I n (mkₐ I x) = Ideal.Quotient.mk (I ^ n) (x.val n) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (n : ℕ) (x : AdicCompletion.AdicCauchySequence I R)
Goal: (AdicCompletion.evalₐ I n) ((AdicCompletion.mkₐ I) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n)
-- AdicCompletion.Ideal.mk_eq_mk
theorem Ideal.mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R) :
    Ideal.Quotient.mk (I ^ m) (r.val n) = Ideal.Quotient.mk (I ^ m) (r.val m) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {m n : ℕ} (hmn : m ≤ n) (r : AdicCompletion.AdicCauchySequence I R)
Goal: (Ideal.Quotient.mk (I ^ m)) (↑r n) = (Ideal.Quotient.mk (I ^ m)) (↑r m)
-- AdicCompletion.smul_mk
theorem smul_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R)
    (x : AdicCauchySequence I M) :
    r.val n • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val n) =
      r.val m • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val m) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {m n : ℕ} (hmn : m ≤ n) (r : AdicCompletion.AdicCauchySequence I R) (x : AdicCompletion.AdicCauchySequence I M)
Goal: ↑r n • Submodule.Quotient.mk (↑x n) = ↑r m • Submodule.Quotient.mk (↑x m)
-- AdicCompletion.mk_smul_mk
@[local simp]
theorem mk_smul_mk (r : R) (x : M) :
    Ideal.Quotient.mk (I • ⊤) r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x
      = r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] (r : R) (x : M)
Goal: (Ideal.Quotient.mk (I • ⊤)) r • Submodule.Quotient.mk x = r • Submodule.Quotient.mk x
-- AdicCompletion.val_smul_eq_evalₐ_smul
theorem val_smul_eq_evalₐ_smul (n : ℕ) (r : AdicCompletion I R)
    (x : M ⧸ (I ^ n • ⊤ : Submodule R M)) : r.val n • x = evalₐ I n r • x 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] (n : ℕ) (r : AdicCompletion I R) (x : M ⧸ I ^ n • ⊤)
Goal: ↑r n • x = (AdicCompletion.evalₐ I n) r • x
-- AdicCompletion.smul_eval
@[simp]
theorem smul_eval (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M) :
    (r • x).val n = r.val n • x.val n 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M)
Goal: ↑(r • x) n = ↑r n • ↑x n
-- Polynomial.hermite_succ
@[simp]
theorem hermite_succ (n : ℕ) : hermite (n + 1) = X * hermite n - derivative (hermite n) 
Arguments: (n : ℕ)
Goal: Polynomial.hermite (n + 1) = Polynomial.X * Polynomial.hermite n - Polynomial.derivative (Polynomial.hermite n)
-- Polynomial.hermite_eq_iterate
theorem hermite_eq_iterate (n : ℕ) : hermite n = (fun p => X * p - derivative p)^[n] 1 
Arguments: (n : ℕ)
Goal: Polynomial.hermite n = (fun p => Polynomial.X * p - Polynomial.derivative p)^[n] 1
-- Polynomial.hermite_zero
@[simp]
theorem hermite_zero : hermite 0 = C 1 
Goal: Polynomial.hermite 0 = Polynomial.C 1