File: Mathlib/RingTheory/AdicCompletion/Basic.lean

full_name: IsHausdorff.haus'
code: /-- A module `M` is Hausdorff with respect to an ideal `I` if `⋂ I^n M = 0`. -/
class IsHausdorff : Prop where
  haus' : ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0
goal: (∀ (n : ℕ), x ≡ 0 [SMOD I ^ n • ⊤]) → x = 0

full_name: IsHausdorff
code: /-- A module `M` is Hausdorff with respect to an ideal `I` if `⋂ I^n M = 0`. -/
class IsHausdorff : Prop where
  haus' : ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0
goal: Prop

full_name: IsPrecomplete.prec'
code: /-- A module `M` is precomplete with respect to an ideal `I` if every Cauchy sequence converges. -/
class IsPrecomplete : Prop where
  prec' : ∀ f : ℕ → M, (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
    ∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)]
goal: (∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤]

full_name: IsPrecomplete
code: /-- A module `M` is precomplete with respect to an ideal `I` if every Cauchy sequence converges. -/
class IsPrecomplete : Prop where
  prec' : ∀ f : ℕ → M, (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
    ∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)]
goal: Prop

full_name: IsAdicComplete
code: /-- A module `M` is `I`-adically complete if it is Hausdorff and precomplete. -/
class IsAdicComplete extends IsHausdorff I M, IsPrecomplete I M : Prop
goal: Prop

full_name: IsHausdorff.haus
code: theorem IsHausdorff.haus (_ : IsHausdorff I M) :
    ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0 
goal: IsHausdorff I M → ∀ (x : M), (∀ (n : ℕ), x ≡ 0 [SMOD I ^ n • ⊤]) → x = 0

full_name: isHausdorff_iff
code: theorem isHausdorff_iff :
    IsHausdorff I M ↔ ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0 
goal: IsHausdorff I M ↔ ∀ (x : M), (∀ (n : ℕ), x ≡ 0 [SMOD I ^ n • ⊤]) → x = 0

full_name: IsPrecomplete.prec
code: theorem IsPrecomplete.prec (_ : IsPrecomplete I M) {f : ℕ → M} :
    (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
      ∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)] 
goal: IsPrecomplete I M →
  ∀ {f : ℕ → M}, (∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤]

full_name: isPrecomplete_iff
code: theorem isPrecomplete_iff :
    IsPrecomplete I M ↔
      ∀ f : ℕ → M,
        (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
          ∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)] 
goal: IsPrecomplete I M ↔
  ∀ (f : ℕ → M), (∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤]

full_name: Hausdorffification
code: /-- The Hausdorffification of a module with respect to an ideal. -/
abbrev Hausdorffification : Type _ 
goal: Type u_2

full_name: AdicCompletion.transitionMap
code: /-- The canonical linear map `M ⧸ (I ^ n • ⊤) →ₗ[R] M ⧸ (I ^ m • ⊤)` for `m ≤ n` used
to define `AdicCompletion`. -/
def AdicCompletion.transitionMap {m n : ℕ} (hmn : m ≤ n) :
    M ⧸ (I ^ n • ⊤ : Submodule R M) →ₗ[R] M ⧸ (I ^ m • ⊤ : Submodule R M) 
goal: M ⧸ I ^ n • ⊤ →ₗ[R] M ⧸ I ^ m • ⊤

full_name: AdicCompletion
code: /-- The completion of a module with respect to an ideal. This is not necessarily Hausdorff.
In fact, this is only complete if the ideal is finitely generated. -/
def AdicCompletion : Type _ 
goal: Type u_2

full_name: IsHausdorff.bot
code: instance bot : IsHausdorff (⊥ : Ideal R) M 
goal: IsHausdorff ⊥ M

full_name: IsHausdorff.subsingleton
code: protected theorem subsingleton (h : IsHausdorff (⊤ : Ideal R) M) : Subsingleton M 
goal: Subsingleton M

full_name: IsHausdorff.of_subsingleton
code: instance (priority := 100) of_subsingleton [Subsingleton M] : IsHausdorff I M 
goal: IsHausdorff I M

full_name: IsHausdorff.iInf_pow_smul
code: theorem iInf_pow_smul (h : IsHausdorff I M) : (⨅ n : ℕ, I ^ n • ⊤ : Submodule R M) = ⊥ 
goal: ⨅ n, I ^ n • ⊤ = ⊥

full_name: Hausdorffification.of
code: /-- The canonical linear map to the Hausdorffification. -/
def of : M →ₗ[R] Hausdorffification I M 
goal: M →ₗ[R] Hausdorffification I M

full_name: Hausdorffification.induction_on
code: @[elab_as_elim]
theorem induction_on {C : Hausdorffification I M → Prop} (x : Hausdorffification I M)
    (ih : ∀ x, C (of I M x)) : C x 
goal: C x

full_name: Hausdorffification.instIsHausdorff
code: instance : IsHausdorff I (Hausdorffification I M) 
goal: IsHausdorff I (Hausdorffification I M)

full_name: Hausdorffification.lift
code: /-- Universal property of Hausdorffification: any linear map to a Hausdorff module extends to a
unique map from the Hausdorffification. -/
def lift (f : M →ₗ[R] N) : Hausdorffification I M →ₗ[R] N 
goal: Hausdorffification I M →ₗ[R] N

full_name: Hausdorffification.lift_of
code: theorem lift_of (f : M →ₗ[R] N) (x : M) : lift I f (of I M x) = f x 
goal: (Hausdorffification.lift I f) ((Hausdorffification.of I M) x) = f x

full_name: Hausdorffification.lift_comp_of
code: theorem lift_comp_of (f : M →ₗ[R] N) : (lift I f).comp (of I M) = f 
goal: Hausdorffification.lift I f ∘ₗ Hausdorffification.of I M = f

full_name: Hausdorffification.lift_eq
code: /-- Uniqueness of lift. -/
theorem lift_eq (f : M →ₗ[R] N) (g : Hausdorffification I M →ₗ[R] N) (hg : g.comp (of I M) = f) :
    g = lift I f 
goal: g = Hausdorffification.lift I f

full_name: IsPrecomplete.bot
code: instance bot : IsPrecomplete (⊥ : Ideal R) M 
goal: IsPrecomplete ⊥ M

full_name: IsPrecomplete.top
code: instance top : IsPrecomplete (⊤ : Ideal R) M 
goal: IsPrecomplete ⊤ M

full_name: IsPrecomplete.of_subsingleton
code: instance (priority := 100) of_subsingleton [Subsingleton M] : IsPrecomplete I M 
goal: IsPrecomplete I M

full_name: AdicCompletion.submodule
code: /-- `AdicCompletion` is the submodule of compatible families in
`∀ n : ℕ, M ⧸ (I ^ n • ⊤)`. -/
def submodule : Submodule R (∀ n : ℕ, M ⧸ (I ^ n • ⊤ : Submodule R M)) 
goal: Submodule R ((n : ℕ) → M ⧸ I ^ n • ⊤)

full_name: AdicCompletion.instZero
code: instance : Zero (AdicCompletion I M) 
goal: Zero (AdicCompletion I M)

full_name: AdicCompletion.instAdd
code: instance : Add (AdicCompletion I M) 
goal: Add (AdicCompletion I M)

full_name: AdicCompletion.instNeg
code: instance : Neg (AdicCompletion I M) 
goal: Neg (AdicCompletion I M)

full_name: AdicCompletion.instSub
code: instance : Sub (AdicCompletion I M) 
goal: Sub (AdicCompletion I M)

full_name: AdicCompletion.instSMulNat
code: instance : SMul ℕ (AdicCompletion I M) 
goal: SMul ℕ (AdicCompletion I M)

full_name: AdicCompletion.instSMulInt
code: instance : SMul ℤ (AdicCompletion I M) 
goal: SMul ℤ (AdicCompletion I M)

full_name: AdicCompletion.instAddCommGroup
code: instance : AddCommGroup (AdicCompletion I M) 
goal: AddCommGroup (AdicCompletion I M)

full_name: AdicCompletion.instSMul
code: instance : SMul R (AdicCompletion I M) 
goal: SMul R (AdicCompletion I M)

full_name: AdicCompletion.instModule
code: instance : Module R (AdicCompletion I M) 
goal: Module R (AdicCompletion I M)

full_name: AdicCompletion.incl
code: /-- The canonical inclusion from the completion to the product. -/
@[simps]
def incl : AdicCompletion I M →ₗ[R] (∀ n, M ⧸ (I ^ n • ⊤ : Submodule R M)) 
goal: AdicCompletion I M →ₗ[R] (n : ℕ) → M ⧸ I ^ n • ⊤

full_name: AdicCompletion.incl_apply
code: /-- The canonical inclusion from the completion to the product. -/
@[simps]
def incl : AdicCompletion I M →ₗ[R] (∀ n, M ⧸ (I ^ n • ⊤ : Submodule R M)) 
goal: (AdicCompletion.incl I M) x n = ↑x n

full_name: AdicCompletion.of
code: /-- The canonical linear map to the completion. -/
def of : M →ₗ[R] AdicCompletion I M 
goal: M →ₗ[R] AdicCompletion I M

full_name: AdicCompletion.of_apply
code: @[simp]
theorem of_apply (x : M) (n : ℕ) : (of I M x).1 n = mkQ (I ^ n • ⊤ : Submodule R M) x 
goal: ↑((AdicCompletion.of I M) x) n = (I ^ n • ⊤).mkQ x

full_name: AdicCompletion.eval
code: /-- Linearly evaluating a sequence in the completion at a given input. -/
def eval (n : ℕ) : AdicCompletion I M →ₗ[R] M ⧸ (I ^ n • ⊤ : Submodule R M) 
goal: AdicCompletion I M →ₗ[R] M ⧸ I ^ n • ⊤

full_name: AdicCompletion.coe_eval
code: @[simp]
theorem coe_eval (n : ℕ) :
    (eval I M n : AdicCompletion I M → M ⧸ (I ^ n • ⊤ : Submodule R M)) = fun f => f.1 n 
goal: ⇑(AdicCompletion.eval I M n) = fun f => ↑f n

full_name: AdicCompletion.eval_apply
code: theorem eval_apply (n : ℕ) (f : AdicCompletion I M) : eval I M n f = f.1 n 
goal: (AdicCompletion.eval I M n) f = ↑f n

full_name: AdicCompletion.eval_of
code: theorem eval_of (n : ℕ) (x : M) : eval I M n (of I M x) = mkQ (I ^ n • ⊤ : Submodule R M) x 
goal: (AdicCompletion.eval I M n) ((AdicCompletion.of I M) x) = (I ^ n • ⊤).mkQ x

full_name: AdicCompletion.eval_comp_of
code: @[simp]
theorem eval_comp_of (n : ℕ) : (eval I M n).comp (of I M) = mkQ _ 
goal: AdicCompletion.eval I M n ∘ₗ AdicCompletion.of I M = (I ^ n • ⊤).mkQ

full_name: AdicCompletion.eval_surjective
code: theorem eval_surjective (n : ℕ) : Function.Surjective (eval I M n) 
goal: Function.Surjective ⇑(AdicCompletion.eval I M n)

full_name: AdicCompletion.range_eval
code: @[simp]
theorem range_eval (n : ℕ) : LinearMap.range (eval I M n) = ⊤ 
goal: LinearMap.range (AdicCompletion.eval I M n) = ⊤

full_name: AdicCompletion.val_zero
code: @[simp]
theorem val_zero (n : ℕ) : (0 : AdicCompletion I M).val n = 0 
goal: ↑0 n = 0

full_name: AdicCompletion.val_add
code: @[simp]
theorem val_add (n : ℕ) (f g : AdicCompletion I M) : (f + g).val n = f.val n + g.val n 
goal: ↑(f + g) n = ↑f n + ↑g n

full_name: AdicCompletion.val_sub
code: @[simp]
theorem val_sub (n : ℕ) (f g : AdicCompletion I M) : (f - g).val n = f.val n - g.val n 
goal: ↑(f - g) n = ↑f n - ↑g n

full_name: AdicCompletion.val_sum
code: @[simp]
theorem val_sum {α : Type*} (s : Finset α) (f : α → AdicCompletion I M) (n : ℕ) :
    (Finset.sum s f).val n = Finset.sum s (fun a ↦ (f a).val n) 
goal: ↑(s.sum f) n = ∑ a ∈ s, ↑(f a) n

full_name: AdicCompletion.val_smul
code: theorem val_smul (n : ℕ) (r : R) (f : AdicCompletion I M) : (r • f).val n = r • f.val n 
goal: ↑(r • f) n = r • ↑f n

full_name: AdicCompletion.ext
code: @[ext]
theorem ext {x y : AdicCompletion I M} (h : ∀ n, x.val n = y.val n) : x = y 
goal: x = y

full_name: AdicCompletion.ext_iff
code: theorem ext_iff {x y : AdicCompletion I M} : x = y ↔ ∀ n, x.val n = y.val n 
goal: x = y ↔ ∀ (n : ℕ), ↑x n = ↑y n

full_name: AdicCompletion.instIsHausdorff
code: instance : IsHausdorff I (AdicCompletion I M) 
goal: IsHausdorff I (AdicCompletion I M)

full_name: AdicCompletion.transitionMap_mk
code: @[simp]
theorem transitionMap_mk {m n : ℕ} (hmn : m ≤ n) (x : M) :
    transitionMap I M hmn
      (Submodule.Quotient.mk (p := (I ^ n • ⊤ : Submodule R M)) x) =
      Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) x 
goal: (AdicCompletion.transitionMap I M hmn) (Submodule.Quotient.mk x) = Submodule.Quotient.mk x

full_name: AdicCompletion.transitionMap_eq
code: @[simp]
theorem transitionMap_eq (n : ℕ) : transitionMap I M (Nat.le_refl n) = LinearMap.id 
goal: AdicCompletion.transitionMap I M ⋯ = LinearMap.id

full_name: AdicCompletion.transitionMap_comp
code: @[simp]
theorem transitionMap_comp {m n k : ℕ} (hmn : m ≤ n) (hnk : n ≤ k) :
    transitionMap I M hmn ∘ₗ transitionMap I M hnk = transitionMap I M (hmn.trans hnk) 
goal: AdicCompletion.transitionMap I M hmn ∘ₗ AdicCompletion.transitionMap I M hnk = AdicCompletion.transitionMap I M ⋯

full_name: AdicCompletion.transitionMap_comp_apply
code: @[simp]
theorem transitionMap_comp_apply {m n k : ℕ} (hmn : m ≤ n) (hnk : n ≤ k)
    (x : M ⧸ (I ^ k • ⊤ : Submodule R M)) :
    transitionMap I M hmn (transitionMap I M hnk x) = transitionMap I M (hmn.trans hnk) x 
goal: (AdicCompletion.transitionMap I M hmn) ((AdicCompletion.transitionMap I M hnk) x) =
  (AdicCompletion.transitionMap I M ⋯) x

full_name: AdicCompletion.transitionMap_comp_eval_apply
code: @[simp]
theorem transitionMap_comp_eval_apply {m n : ℕ} (hmn : m ≤ n) (x : AdicCompletion I M) :
    transitionMap I M hmn (x.val n) = x.val m 
goal: (AdicCompletion.transitionMap I M hmn) (↑x n) = ↑x m

full_name: AdicCompletion.transitionMap_comp_eval
code: @[simp]
theorem transitionMap_comp_eval {m n : ℕ} (hmn : m ≤ n) :
    transitionMap I M hmn ∘ₗ eval I M n = eval I M m 
goal: AdicCompletion.transitionMap I M hmn ∘ₗ AdicCompletion.eval I M n = AdicCompletion.eval I M m

full_name: AdicCompletion.IsAdicCauchy
code: /-- A sequence `ℕ → M` is an `I`-adic Cauchy sequence if for every `m ≤ n`,
`f m ≡ f n` modulo `I ^ m • ⊤`. -/
def IsAdicCauchy (f : ℕ → M) : Prop 
goal: Prop

full_name: AdicCompletion.AdicCauchySequence
code: /-- The type of `I`-adic Cauchy sequences. -/
def AdicCauchySequence : Type _ 
goal: Type u_2

full_name: AdicCompletion.AdicCauchySequence.submodule
code: /-- The type of `I`-adic cauchy sequences is a submodule of the product `ℕ → M`. -/
def submodule : Submodule R (ℕ → M) 
goal: Submodule R (ℕ → M)

full_name: AdicCompletion.AdicCauchySequence.instZero
code: instance : Zero (AdicCauchySequence I M) 
goal: Zero (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instAdd
code: instance : Add (AdicCauchySequence I M) 
goal: Add (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instNeg
code: instance : Neg (AdicCauchySequence I M) 
goal: Neg (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instSub
code: instance : Sub (AdicCauchySequence I M) 
goal: Sub (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instSMulNat
code: instance : SMul ℕ (AdicCauchySequence I M) 
goal: SMul ℕ (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instSMulInt
code: instance : SMul ℤ (AdicCauchySequence I M) 
goal: SMul ℤ (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instAddCommGroup
code: instance : AddCommGroup (AdicCauchySequence I M) 
goal: AddCommGroup (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instSMul
code: instance : SMul R (AdicCauchySequence I M) 
goal: SMul R (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instModule
code: instance : Module R (AdicCauchySequence I M) 
goal: Module R (AdicCompletion.AdicCauchySequence I M)

full_name: AdicCompletion.AdicCauchySequence.instCoeFunForallNat
code: instance : CoeFun (AdicCauchySequence I M) (fun _ ↦ ℕ → M) 
goal: CoeFun (AdicCompletion.AdicCauchySequence I M) fun x => ℕ → M

full_name: AdicCompletion.AdicCauchySequence.zero_apply
code: @[simp]
theorem zero_apply (n : ℕ) : (0 : AdicCauchySequence I M) n = 0 
goal: ↑0 n = 0

full_name: AdicCompletion.AdicCauchySequence.add_apply
code: @[simp]
theorem add_apply (n : ℕ) (f g : AdicCauchySequence I M) : (f + g) n = f n + g n 
goal: ↑(f + g) n = ↑f n + ↑g n

full_name: AdicCompletion.AdicCauchySequence.sub_apply
code: @[simp]
theorem sub_apply (n : ℕ) (f g : AdicCauchySequence I M) : (f - g) n = f n - g n 
goal: ↑(f - g) n = ↑f n - ↑g n

full_name: AdicCompletion.AdicCauchySequence.smul_apply
code: @[simp]
theorem smul_apply (n : ℕ) (r : R) (f : AdicCauchySequence I M) : (r • f) n = r • f n 
goal: ↑(r • f) n = r • ↑f n

full_name: AdicCompletion.AdicCauchySequence.ext
code: @[ext]
theorem ext {x y : AdicCauchySequence I M} (h : ∀ n, x n = y n) : x = y 
goal: x = y

full_name: AdicCompletion.AdicCauchySequence.ext_iff
code: theorem ext_iff {x y : AdicCauchySequence I M} : x = y ↔ ∀ n, x n = y n 
goal: x = y ↔ ∀ (n : ℕ), ↑x n = ↑y n

full_name: AdicCompletion.AdicCauchySequence.mk_eq_mk
code: /-- The defining property of an adic cauchy sequence unwrapped. -/
theorem mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (f : AdicCauchySequence I M) :
    Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (f n) =
      Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (f m) 
goal: Submodule.Quotient.mk (↑f n) = Submodule.Quotient.mk (↑f m)

full_name: AdicCompletion.isAdicCauchy_iff
code: /-- The `I`-adic cauchy condition can be checked on successive `n`.-/
theorem isAdicCauchy_iff (f : ℕ → M) :
    IsAdicCauchy I M f ↔ ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)] 
goal: AdicCompletion.IsAdicCauchy I M f ↔ ∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤]

full_name: AdicCompletion.AdicCauchySequence.mk
code: /-- Construct `I`-adic cauchy sequence from sequence satisfying the successive cauchy condition. -/
@[simps]
def AdicCauchySequence.mk (f : ℕ → M)
    (h : ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)]) : AdicCauchySequence I M 
goal: AdicCompletion.AdicCauchySequence I M

full_name: AdicCompletion.AdicCauchySequence.mk_coe
code: /-- Construct `I`-adic cauchy sequence from sequence satisfying the successive cauchy condition. -/
@[simps]
def AdicCauchySequence.mk (f : ℕ → M)
    (h : ∀ n, f n ≡ f (n + 1) [SMOD (I ^ n • ⊤ : Submodule R M)]) : AdicCauchySequence I M 
goal: ∀ (a : ℕ), ↑(AdicCompletion.AdicCauchySequence.mk I M f h) a = f a

full_name: AdicCompletion.mk_apply_coe
code: /-- The canonical linear map from cauchy sequences to the completion. -/
@[simps]
def mk : AdicCauchySequence I M →ₗ[R] AdicCompletion I M 
goal: ↑((AdicCompletion.mk I M) f) n = (I ^ n • ⊤).mkQ (↑f n)

full_name: AdicCompletion.mk
code: /-- The canonical linear map from cauchy sequences to the completion. -/
@[simps]
def mk : AdicCauchySequence I M →ₗ[R] AdicCompletion I M 
goal: AdicCompletion.AdicCauchySequence I M →ₗ[R] AdicCompletion I M

full_name: AdicCompletion.mk_zero_of
code: /-- Criterion for checking that an adic cauchy sequence is mapped to zero in the adic completion. -/
theorem mk_zero_of (f : AdicCauchySequence I M)
    (h : ∃ k : ℕ, ∀ n ≥ k, ∃ m ≥ n, ∃ l ≥ n, f m ∈ (I ^ l • ⊤ : Submodule R M)) :
    AdicCompletion.mk I M f = 0 
goal: (AdicCompletion.mk I M) f = 0

full_name: AdicCompletion.mk_surjective
code: /-- Every element in the adic completion is represented by a Cauchy sequence. -/
theorem mk_surjective : Function.Surjective (mk I M) 
goal: Function.Surjective ⇑(AdicCompletion.mk I M)

full_name: AdicCompletion.induction_on
code: /-- To show a statement about an element of `adicCompletion I M`, it suffices to check it
on Cauchy sequences. -/
theorem induction_on {p : AdicCompletion I M → Prop} (x : AdicCompletion I M)
    (h : ∀ (f : AdicCauchySequence I M), p (mk I M f)) : p x 
goal: p x

full_name: AdicCompletion.lift
code: /-- Lift a compatible family of linear maps `M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N)` to
the `I`-adic completion of `M`. -/
def lift (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
    (h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m) :
    M →ₗ[R] AdicCompletion I N 
goal: M →ₗ[R] AdicCompletion I N

full_name: AdicCompletion.eval_lift
code: @[simp]
lemma eval_lift (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
    (h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m)
    (n : ℕ) : eval I N n ∘ₗ lift I f h = f n 
goal: AdicCompletion.eval I N n ∘ₗ AdicCompletion.lift I f ⋯ = f n

full_name: AdicCompletion.eval_lift_apply
code: @[simp]
lemma eval_lift_apply (f : ∀ (n : ℕ), M →ₗ[R] N ⧸ (I ^ n • ⊤ : Submodule R N))
    (h : ∀ {m n : ℕ} (hle : m ≤ n), transitionMap I N hle ∘ₗ f n = f m)
    (n : ℕ) (x : M) : (lift I f h x).val n = f n x 
goal: ↑((AdicCompletion.lift I f ⋯) x) n = (f n) x

full_name: IsAdicComplete.bot
code: instance bot : IsAdicComplete (⊥ : Ideal R) M 
goal: IsAdicComplete ⊥ M

full_name: IsAdicComplete.subsingleton
code: protected theorem subsingleton (h : IsAdicComplete (⊤ : Ideal R) M) : Subsingleton M 
goal: Subsingleton M

full_name: IsAdicComplete.of_subsingleton
code: instance (priority := 100) of_subsingleton [Subsingleton M] : IsAdicComplete I M 
goal: IsAdicComplete I M

full_name: IsAdicComplete.le_jacobson_bot
code: theorem le_jacobson_bot [IsAdicComplete I R] : I ≤ (⊥ : Ideal R).jacobson 
goal: I ≤ ⊥.jacobson