File: Mathlib/Data/Semiquot.lean

full_name: Semiquot.s
code: /-- A member of `Semiquot α` is classically a nonempty `Set α`,
  and in the VM is represented by an element of `α`; the relation
  between these is that the VM element is required to be a member
  of the set `s`. The specific element of `s` that the VM computes
  is hidden by a quotient construction, allowing for the representation
  of nondeterministic functions. -/
  -- Porting note: removed universe parameter
structure Semiquot (α : Type*) where mk' ::
  /-- Set containing some element of `α`-/
  s : Set α
  /-- Assertion of non-emptiness via `Trunc`-/
  val : Trunc s
goal: Set α

full_name: Semiquot
code: /-- A member of `Semiquot α` is classically a nonempty `Set α`,
  and in the VM is represented by an element of `α`; the relation
  between these is that the VM element is required to be a member
  of the set `s`. The specific element of `s` that the VM computes
  is hidden by a quotient construction, allowing for the representation
  of nondeterministic functions. -/
  -- Porting note: removed universe parameter
structure Semiquot (α : Type*) where mk' ::
  /-- Set containing some element of `α`-/
  s : Set α
  /-- Assertion of non-emptiness via `Trunc`-/
  val : Trunc s
goal: Type u_1

full_name: Semiquot.mk'
code: /-- A member of `Semiquot α` is classically a nonempty `Set α`,
  and in the VM is represented by an element of `α`; the relation
  between these is that the VM element is required to be a member
  of the set `s`. The specific element of `s` that the VM computes
  is hidden by a quotient construction, allowing for the representation
  of nondeterministic functions. -/
  -- Porting note: removed universe parameter
structure Semiquot (α : Type*) where mk' ::
  /-- Set containing some element of `α`-/
  s : Set α
  /-- Assertion of non-emptiness via `Trunc`-/
  val : Trunc s
goal: Semiquot α

full_name: Semiquot.val
code: /-- A member of `Semiquot α` is classically a nonempty `Set α`,
  and in the VM is represented by an element of `α`; the relation
  between these is that the VM element is required to be a member
  of the set `s`. The specific element of `s` that the VM computes
  is hidden by a quotient construction, allowing for the representation
  of nondeterministic functions. -/
  -- Porting note: removed universe parameter
structure Semiquot (α : Type*) where mk' ::
  /-- Set containing some element of `α`-/
  s : Set α
  /-- Assertion of non-emptiness via `Trunc`-/
  val : Trunc s
goal: Trunc ↑self.s

full_name: Semiquot.instMembership
code: instance : Membership α (Semiquot α) 
goal: Membership α (Semiquot α)

full_name: Semiquot.mk
code: /-- Construct a `Semiquot α` from `h : a ∈ s` where `s : Set α`. -/
def mk {a : α} {s : Set α} (h : a ∈ s) : Semiquot α 
goal: Semiquot α

full_name: Semiquot.ext_s
code: theorem ext_s {q₁ q₂ : Semiquot α} : q₁ = q₂ ↔ q₁.s = q₂.s 
goal: q₁ = q₂ ↔ q₁.s = q₂.s

full_name: Semiquot.ext
code: theorem ext {q₁ q₂ : Semiquot α} : q₁ = q₂ ↔ ∀ a, a ∈ q₁ ↔ a ∈ q₂ 
goal: q₁ = q₂ ↔ ∀ (a : α), a ∈ q₁ ↔ a ∈ q₂

full_name: Semiquot.exists_mem
code: theorem exists_mem (q : Semiquot α) : ∃ a, a ∈ q 
goal: ∃ a, a ∈ q

full_name: Semiquot.eq_mk_of_mem
code: theorem eq_mk_of_mem {q : Semiquot α} {a : α} (h : a ∈ q) : q = @mk _ a q.1 h 
goal: q = Semiquot.mk h

full_name: Semiquot.nonempty
code: theorem nonempty (q : Semiquot α) : q.s.Nonempty 
goal: q.s.Nonempty

full_name: Semiquot.pure
code: /-- `pure a` is `a` reinterpreted as an unspecified element of `{a}`. -/
protected def pure (a : α) : Semiquot α 
goal: Semiquot α

full_name: Semiquot.mem_pure'
code: @[simp]
theorem mem_pure' {a b : α} : a ∈ Semiquot.pure b ↔ a = b 
goal: a ∈ Semiquot.pure b ↔ a = b

full_name: Semiquot.blur'
code: /-- Replace `s` in a `Semiquot` with a superset. -/
def blur' (q : Semiquot α) {s : Set α} (h : q.s ⊆ s) : Semiquot α 
goal: Semiquot α

full_name: Semiquot.blur
code: /-- Replace `s` in a `q : Semiquot α` with a union `s ∪ q.s` -/
def blur (s : Set α) (q : Semiquot α) : Semiquot α 
goal: Semiquot α

full_name: Semiquot.blur_eq_blur'
code: theorem blur_eq_blur' (q : Semiquot α) (s : Set α) (h : q.s ⊆ s) : blur s q = blur' q h 
goal: Semiquot.blur s q = q.blur' h

full_name: Semiquot.mem_blur'
code: @[simp]
theorem mem_blur' (q : Semiquot α) {s : Set α} (h : q.s ⊆ s) {a : α} : a ∈ blur' q h ↔ a ∈ s 
goal: a ∈ q.blur' h ↔ a ∈ s

full_name: Semiquot.ofTrunc
code: /-- Convert a `Trunc α` to a `Semiquot α`. -/
def ofTrunc (q : Trunc α) : Semiquot α 
goal: Semiquot α

full_name: Semiquot.toTrunc
code: /-- Convert a `Semiquot α` to a `Trunc α`. -/
def toTrunc (q : Semiquot α) : Trunc α 
goal: Trunc α

full_name: Semiquot.liftOn
code: /-- If `f` is a constant on `q.s`, then `q.liftOn f` is the value of `f`
at any point of `q`. -/
def liftOn (q : Semiquot α) (f : α → β) (h : ∀ a ∈ q, ∀ b ∈ q, f a = f b) : β 
goal: β

full_name: Semiquot.liftOn_ofMem
code: theorem liftOn_ofMem (q : Semiquot α) (f : α → β)
    (h : ∀ a ∈ q, ∀ b ∈ q, f a = f b) (a : α) (aq : a ∈ q) : liftOn q f h = f a 
goal: q.liftOn f h = f a

full_name: Semiquot.map
code: /-- Apply a function to the unknown value stored in a `Semiquot α`. -/
def map (f : α → β) (q : Semiquot α) : Semiquot β 
goal: Semiquot β

full_name: Semiquot.mem_map
code: @[simp]
theorem mem_map (f : α → β) (q : Semiquot α) (b : β) : b ∈ map f q ↔ ∃ a, a ∈ q ∧ f a = b 
goal: b ∈ Semiquot.map f q ↔ ∃ a ∈ q, f a = b

full_name: Semiquot.bind
code: /-- Apply a function returning a `Semiquot` to a `Semiquot`. -/
def bind (q : Semiquot α) (f : α → Semiquot β) : Semiquot β 
goal: Semiquot β

full_name: Semiquot.mem_bind
code: @[simp]
theorem mem_bind (q : Semiquot α) (f : α → Semiquot β) (b : β) :
    b ∈ bind q f ↔ ∃ a ∈ q, b ∈ f a 
goal: b ∈ q.bind f ↔ ∃ a ∈ q, b ∈ f a

full_name: Semiquot.instMonad
code: instance : Monad Semiquot 
goal: Monad Semiquot

full_name: Semiquot.map_def
code: @[simp]
theorem map_def {β} : ((· <$> ·) : (α → β) → Semiquot α → Semiquot β) = map 
goal: (fun x x_1 => x <$> x_1) = Semiquot.map

full_name: Semiquot.bind_def
code: @[simp]
theorem bind_def {β} : ((· >>= ·) : Semiquot α → (α → Semiquot β) → Semiquot β) = bind 
goal: (fun x x_1 => x >>= x_1) = Semiquot.bind

full_name: Semiquot.mem_pure
code: @[simp]
theorem mem_pure {a b : α} : a ∈ (pure b : Semiquot α) ↔ a = b 
goal: a ∈ pure b ↔ a = b

full_name: Semiquot.mem_pure_self
code: theorem mem_pure_self (a : α) : a ∈ (pure a : Semiquot α) 
goal: a ∈ pure a

full_name: Semiquot.pure_inj
code: @[simp]
theorem pure_inj {a b : α} : (pure a : Semiquot α) = pure b ↔ a = b 
goal: pure a = pure b ↔ a = b

full_name: Semiquot.instLawfulMonad
code: instance : LawfulMonad Semiquot 
goal: LawfulMonad Semiquot

full_name: Semiquot.instLE
code: instance : LE (Semiquot α) 
goal: LE (Semiquot α)

full_name: Semiquot.partialOrder
code: instance partialOrder : PartialOrder (Semiquot α) 
goal: PartialOrder (Semiquot α)

full_name: Semiquot.instSemilatticeSup
code: instance : SemilatticeSup (Semiquot α) 
goal: SemilatticeSup (Semiquot α)

full_name: Semiquot.pure_le
code: @[simp]
theorem pure_le {a : α} {s : Semiquot α} : pure a ≤ s ↔ a ∈ s 
goal: pure a ≤ s ↔ a ∈ s

full_name: Semiquot.IsPure
code: /-- Assert that a `Semiquot` contains only one possible value. -/
def IsPure (q : Semiquot α) : Prop 
goal: Prop

full_name: Semiquot.get
code: /-- Extract the value from an `IsPure` semiquotient. -/
def get (q : Semiquot α) (h : q.IsPure) : α 
goal: α

full_name: Semiquot.get_mem
code: theorem get_mem {q : Semiquot α} (p) : get q p ∈ q 
goal: q.get p ∈ q

full_name: Semiquot.eq_pure
code: theorem eq_pure {q : Semiquot α} (p) : q = pure (get q p) 
goal: q = pure (q.get p)

full_name: Semiquot.pure_isPure
code: @[simp]
theorem pure_isPure (a : α) : IsPure (pure a)
  
goal: (pure a).IsPure

full_name: Semiquot.isPure_iff
code: theorem isPure_iff {s : Semiquot α} : IsPure s ↔ ∃ a, s = pure a 
goal: s.IsPure ↔ ∃ a, s = pure a

full_name: Semiquot.IsPure.mono
code: theorem IsPure.mono {s t : Semiquot α} (st : s ≤ t) (h : IsPure t) : IsPure s
  
goal: s.IsPure

full_name: Semiquot.IsPure.min
code: theorem IsPure.min {s t : Semiquot α} (h : IsPure t) : s ≤ t ↔ s = t 
goal: s ≤ t ↔ s = t

full_name: Semiquot.isPure_of_subsingleton
code: theorem isPure_of_subsingleton [Subsingleton α] (q : Semiquot α) : IsPure q
  
goal: q.IsPure

full_name: Semiquot.univ
code: /-- `univ : Semiquot α` represents an unspecified element of `univ : Set α`. -/
def univ [Inhabited α] : Semiquot α 
goal: Semiquot α

full_name: Semiquot.instInhabited
code: instance [Inhabited α] : Inhabited (Semiquot α) 
goal: Inhabited (Semiquot α)

full_name: Semiquot.mem_univ
code: @[simp]
theorem mem_univ [Inhabited α] : ∀ a, a ∈ @univ α _ 
goal: a ∈ Semiquot.univ

full_name: Semiquot.univ_unique
code: @[congr]
theorem univ_unique (I J : Inhabited α) : @univ _ I = @univ _ J 
goal: Semiquot.univ = Semiquot.univ

full_name: Semiquot.isPure_univ
code: @[simp]
theorem isPure_univ [Inhabited α] : @IsPure α univ ↔ Subsingleton α 
goal: Semiquot.univ.IsPure ↔ Subsingleton α

full_name: Semiquot.instOrderTopOfInhabited
code: instance [Inhabited α] : OrderTop (Semiquot α) 
goal: OrderTop (Semiquot α)