File: Mathlib/Deprecated/Subring.lean

full_name: IsSubring
code: /-- `S` is a subring: a set containing 1 and closed under multiplication, addition and additive
inverse. -/
structure IsSubring (S : Set R) extends IsAddSubgroup S, IsSubmonoid S : Prop
goal: Prop

full_name: IsSubring.subring
code: /-- Construct a `Subring` from a set satisfying `IsSubring`. -/
def IsSubring.subring {S : Set R} (hs : IsSubring S) : Subring R 
goal: Subring R

full_name: RingHom.isSubring_preimage
code: theorem isSubring_preimage {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) {s : Set S}
    (hs : IsSubring s) : IsSubring (f ⁻¹' s) 
goal: IsSubring (⇑f ⁻¹' s)

full_name: RingHom.isSubring_image
code: theorem isSubring_image {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) {s : Set R}
    (hs : IsSubring s) : IsSubring (f '' s) 
goal: IsSubring (⇑f '' s)

full_name: RingHom.isSubring_set_range
code: theorem isSubring_set_range {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) :
    IsSubring (Set.range f) 
goal: IsSubring (Set.range ⇑f)

full_name: IsSubring.inter
code: theorem IsSubring.inter {S₁ S₂ : Set R} (hS₁ : IsSubring S₁) (hS₂ : IsSubring S₂) :
    IsSubring (S₁ ∩ S₂) 
goal: IsSubring (S₁ ∩ S₂)

full_name: IsSubring.iInter
code: theorem IsSubring.iInter {ι : Sort*} {S : ι → Set R} (h : ∀ y : ι, IsSubring (S y)) :
    IsSubring (Set.iInter S) 
goal: IsSubring (Set.iInter S)

full_name: isSubring_iUnion_of_directed
code: theorem isSubring_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set R}
    (h : ∀ i, IsSubring (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubring (⋃ i, s i) 
goal: IsSubring (⋃ i, s i)

full_name: Ring.closure
code: /-- The smallest subring containing a given subset of a ring, considered as a set. This function
is deprecated; use `Subring.closure`. -/
def closure (s : Set R) 
goal: Set R

full_name: Ring.exists_list_of_mem_closure
code: theorem exists_list_of_mem_closure {a : R} (h : a ∈ closure s) :
    ∃ L : List (List R), (∀ l ∈ L, ∀ x ∈ l, x ∈ s ∨ x = (-1 : R)) ∧ (L.map List.prod).sum = a 
goal: ∃ L, (∀ l ∈ L, ∀ x ∈ l, x ∈ s ∨ x = -1) ∧ (List.map List.prod L).sum = a

full_name: Ring.InClosure.recOn
code: @[elab_as_elim]
protected theorem InClosure.recOn {C : R → Prop} {x : R} (hx : x ∈ closure s) (h1 : C 1)
    (hneg1 : C (-1)) (hs : ∀ z ∈ s, ∀ n, C n → C (z * n)) (ha : ∀ {x y}, C x → C y → C (x + y)) :
    C x 
goal: C x

full_name: Ring.closure.isSubring
code: theorem closure.isSubring : IsSubring (closure s) 
goal: IsSubring (Ring.closure s)

full_name: Ring.mem_closure
code: theorem mem_closure {a : R} : a ∈ s → a ∈ closure s 
goal: a ∈ s → a ∈ Ring.closure s

full_name: Ring.subset_closure
code: theorem subset_closure : s ⊆ closure s 
goal: s ⊆ Ring.closure s

full_name: Ring.closure_subset
code: theorem closure_subset {t : Set R} (ht : IsSubring t) : s ⊆ t → closure s ⊆ t 
goal: s ⊆ t → Ring.closure s ⊆ t

full_name: Ring.closure_subset_iff
code: theorem closure_subset_iff {s t : Set R} (ht : IsSubring t) : closure s ⊆ t ↔ s ⊆ t 
goal: Ring.closure s ⊆ t ↔ s ⊆ t

full_name: Ring.closure_mono
code: theorem closure_mono {s t : Set R} (H : s ⊆ t) : closure s ⊆ closure t 
goal: Ring.closure s ⊆ Ring.closure t

full_name: Ring.image_closure
code: theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) 
goal: ⇑f '' Ring.closure s = Ring.closure (⇑f '' s)