File: Mathlib/Data/PFun.lean

full_name: PFun
code: /-- `PFun α β`, or `α →. β`, is the type of partial functions from
  `α` to `β`. It is defined as `α → Part β`. -/
def PFun (α β : Type*) 
goal: Type (max u_1 u_2)

full_name: «_aux_Mathlib_Data_PFun___macroRules_term_→.__1»
code: /-- `α →. β` is notation for the type `PFun α β` of partial functions from `α` to `β`.  -/
infixr:25 " →. " => PFun
goal: Lean.Macro

full_name: _aux_Mathlib_Data_PFun___unexpand_PFun_1
code: /-- `α →. β` is notation for the type `PFun α β` of partial functions from `α` to `β`.  -/
infixr:25 " →. " => PFun
goal: Lean.PrettyPrinter.Unexpander

full_name: PFun.inhabited
code: instance inhabited : Inhabited (α →. β) 
goal: Inhabited (α →. β)

full_name: PFun.Dom
code: /-- The domain of a partial function -/
def Dom (f : α →. β) : Set α 
goal: Set α

full_name: PFun.mem_dom
code: @[simp]
theorem mem_dom (f : α →. β) (x : α) : x ∈ Dom f ↔ ∃ y, y ∈ f x 
goal: x ∈ f.Dom ↔ ∃ y, y ∈ f x

full_name: PFun.dom_mk
code: @[simp]
theorem dom_mk (p : α → Prop) (f : ∀ a, p a → β) : (PFun.Dom fun x => ⟨p x, f x⟩) = { x | p x } 
goal: (PFun.Dom fun x => { Dom := p x, get := f x }) = {x | p x}

full_name: PFun.dom_eq
code: theorem dom_eq (f : α →. β) : Dom f = { x | ∃ y, y ∈ f x } 
goal: f.Dom = {x | ∃ y, y ∈ f x}

full_name: PFun.fn
code: /-- Evaluate a partial function -/
def fn (f : α →. β) (a : α) : Dom f a → β 
goal: f.Dom a → β

full_name: PFun.fn_apply
code: @[simp]
theorem fn_apply (f : α →. β) (a : α) : f.fn a = (f a).get 
goal: f.fn a = (f a).get

full_name: PFun.evalOpt
code: /-- Evaluate a partial function to return an `Option` -/
def evalOpt (f : α →. β) [D : DecidablePred (· ∈ Dom f)] (x : α) : Option β 
goal: Option β

full_name: PFun.ext'
code: /-- Partial function extensionality -/
theorem ext' {f g : α →. β} (H1 : ∀ a, a ∈ Dom f ↔ a ∈ Dom g) (H2 : ∀ a p q, f.fn a p = g.fn a q) :
    f = g 
goal: f = g

full_name: PFun.ext
code: theorem ext {f g : α →. β} (H : ∀ a b, b ∈ f a ↔ b ∈ g a) : f = g 
goal: f = g

full_name: PFun.asSubtype
code: /-- Turns a partial function into a function out of its domain. -/
def asSubtype (f : α →. β) (s : f.Dom) : β 
goal: β

full_name: PFun.equivSubtype
code: /-- The type of partial functions `α →. β` is equivalent to
the type of pairs `(p : α → Prop, f : Subtype p → β)`. -/
def equivSubtype : (α →. β) ≃ Σp : α → Prop, Subtype p → β 
goal: (α →. β) ≃ (p : α → Prop) × (Subtype p → β)

full_name: PFun.asSubtype_eq_of_mem
code: theorem asSubtype_eq_of_mem {f : α →. β} {x : α} {y : β} (fxy : y ∈ f x) (domx : x ∈ f.Dom) :
    f.asSubtype ⟨x, domx⟩ = y 
goal: f.asSubtype ⟨x, domx⟩ = y

full_name: PFun.lift
code: /-- Turn a total function into a partial function. -/
@[coe]
protected def lift (f : α → β) : α →. β 
goal: α →. β

full_name: PFun.coe
code: instance coe : Coe (α → β) (α →. β) 
goal: Coe (α → β) (α →. β)

full_name: PFun.coe_val
code: @[simp]
theorem coe_val (f : α → β) (a : α) : (f : α →. β) a = Part.some (f a) 
goal: ↑f a = Part.some (f a)

full_name: PFun.dom_coe
code: @[simp]
theorem dom_coe (f : α → β) : (f : α →. β).Dom = Set.univ 
goal: (↑f).Dom = Set.univ

full_name: PFun.lift_injective
code: theorem lift_injective : Injective (PFun.lift : (α → β) → α →. β) 
goal: Function.Injective PFun.lift

full_name: PFun.graph
code: /-- Graph of a partial function `f` as the set of pairs `(x, f x)` where `x` is in the domain of
`f`. -/
def graph (f : α →. β) : Set (α × β) 
goal: Set (α × β)

full_name: PFun.graph'
code: /-- Graph of a partial function as a relation. `x` and `y` are related iff `f x` is defined and
"equals" `y`. -/
def graph' (f : α →. β) : Rel α β 
goal: Rel α β

full_name: PFun.ran
code: /-- The range of a partial function is the set of values
  `f x` where `x` is in the domain of `f`. -/
def ran (f : α →. β) : Set β 
goal: Set β

full_name: PFun.restrict
code: /-- Restrict a partial function to a smaller domain. -/
def restrict (f : α →. β) {p : Set α} (H : p ⊆ f.Dom) : α →. β 
goal: α →. β

full_name: PFun.mem_restrict
code: @[simp]
theorem mem_restrict {f : α →. β} {s : Set α} (h : s ⊆ f.Dom) (a : α) (b : β) :
    b ∈ f.restrict h a ↔ a ∈ s ∧ b ∈ f a 
goal: b ∈ f.restrict h a ↔ a ∈ s ∧ b ∈ f a

full_name: PFun.res
code: /-- Turns a function into a partial function with a prescribed domain. -/
def res (f : α → β) (s : Set α) : α →. β 
goal: α →. β

full_name: PFun.mem_res
code: theorem mem_res (f : α → β) (s : Set α) (a : α) (b : β) : b ∈ res f s a ↔ a ∈ s ∧ f a = b 
goal: b ∈ PFun.res f s a ↔ a ∈ s ∧ f a = b

full_name: PFun.res_univ
code: theorem res_univ (f : α → β) : PFun.res f Set.univ = f 
goal: PFun.res f Set.univ = ↑f

full_name: PFun.dom_iff_graph
code: theorem dom_iff_graph (f : α →. β) (x : α) : x ∈ f.Dom ↔ ∃ y, (x, y) ∈ f.graph 
goal: x ∈ f.Dom ↔ ∃ y, (x, y) ∈ f.graph

full_name: PFun.lift_graph
code: theorem lift_graph {f : α → β} {a b} : (a, b) ∈ (f : α →. β).graph ↔ f a = b 
goal: (a, b) ∈ (↑f).graph ↔ f a = b

full_name: PFun.pure
code: /-- The monad `pure` function, the total constant `x` function -/
protected def pure (x : β) : α →. β 
goal: α →. β

full_name: PFun.bind
code: /-- The monad `bind` function, pointwise `Part.bind` -/
def bind (f : α →. β) (g : β → α →. γ) : α →. γ 
goal: α →. γ

full_name: PFun.bind_apply
code: @[simp]
theorem bind_apply (f : α →. β) (g : β → α →. γ) (a : α) : f.bind g a = (f a).bind fun b => g b a 
goal: f.bind g a = (f a).bind fun b => g b a

full_name: PFun.map
code: /-- The monad `map` function, pointwise `Part.map` -/
def map (f : β → γ) (g : α →. β) : α →. γ 
goal: α →. γ

full_name: PFun.monad
code: instance monad : Monad (PFun α) 
goal: Monad (PFun α)

full_name: PFun.lawfulMonad
code: instance lawfulMonad : LawfulMonad (PFun α) 
goal: LawfulMonad (PFun α)

full_name: PFun.pure_defined
code: theorem pure_defined (p : Set α) (x : β) : p ⊆ (@PFun.pure α _ x).Dom 
goal: p ⊆ (PFun.pure x).Dom

full_name: PFun.bind_defined
code: theorem bind_defined {α β γ} (p : Set α) {f : α →. β} {g : β → α →. γ} (H1 : p ⊆ f.Dom)
    (H2 : ∀ x, p ⊆ (g x).Dom) : p ⊆ (f >>= g).Dom 
goal: p ⊆ (f >>= g).Dom

full_name: PFun.fix
code: /-- First return map. Transforms a partial function `f : α →. β ⊕ α` into the partial function
`α →. β` which sends `a : α` to the first value in `β` it hits by iterating `f`, if such a value
exists. By abusing notation to illustrate, either `f a` is in the `β` part of `β ⊕ α` (in which
case `f.fix a` returns `f a`), or it is undefined (in which case `f.fix a` is undefined as well), or
it is in the `α` part of `β ⊕ α` (in which case we repeat the procedure, so `f.fix a` will return
`f.fix (f a)`). -/
def fix (f : α →. β ⊕ α) : α →. β 
goal: α →. β

full_name: PFun.dom_of_mem_fix
code: theorem dom_of_mem_fix {f : α →. β ⊕ α} {a : α} {b : β} (h : b ∈ f.fix a) : (f a).Dom 
goal: (f a).Dom

full_name: PFun.mem_fix_iff
code: theorem mem_fix_iff {f : α →. β ⊕ α} {a : α} {b : β} :
    b ∈ f.fix a ↔ Sum.inl b ∈ f a ∨ ∃ a', Sum.inr a' ∈ f a ∧ b ∈ f.fix a' 
goal: b ∈ f.fix a ↔ Sum.inl b ∈ f a ∨ ∃ a', Sum.inr a' ∈ f a ∧ b ∈ f.fix a'

full_name: PFun.fix_stop
code: /-- If advancing one step from `a` leads to `b : β`, then `f.fix a = b` -/
theorem fix_stop {f : α →. β ⊕ α} {b : β} {a : α} (hb : Sum.inl b ∈ f a) : b ∈ f.fix a 
goal: b ∈ f.fix a

full_name: PFun.fix_fwd_eq
code: /-- If advancing one step from `a` on `f` leads to `a' : α`, then `f.fix a = f.fix a'` -/
theorem fix_fwd_eq {f : α →. β ⊕ α} {a a' : α} (ha' : Sum.inr a' ∈ f a) : f.fix a = f.fix a' 
goal: f.fix a = f.fix a'

full_name: PFun.fix_fwd
code: theorem fix_fwd {f : α →. β ⊕ α} {b : β} {a a' : α} (hb : b ∈ f.fix a) (ha' : Sum.inr a' ∈ f a) :
    b ∈ f.fix a' 
goal: b ∈ f.fix a'

full_name: PFun.fixInduction
code: /-- A recursion principle for `PFun.fix`. -/
@[elab_as_elim]
def fixInduction {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a : α} (h : b ∈ f.fix a)
    (H : ∀ a', b ∈ f.fix a' → (∀ a'', Sum.inr a'' ∈ f a' → C a'') → C a') : C a 
goal: C a

full_name: PFun.fixInduction_spec
code: theorem fixInduction_spec {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a : α} (h : b ∈ f.fix a)
    (H : ∀ a', b ∈ f.fix a' → (∀ a'', Sum.inr a'' ∈ f a' → C a'') → C a') :
    @fixInduction _ _ C _ _ _ h H = H a h fun a' h' => fixInduction (fix_fwd h h') H 
goal: PFun.fixInduction h H = H a h fun a' h' => PFun.fixInduction ⋯ H

full_name: PFun.fixInduction'
code: /-- Another induction lemma for `b ∈ f.fix a` which allows one to prove a predicate `P` holds for
`a` given that `f a` inherits `P` from `a` and `P` holds for preimages of `b`.
-/
@[elab_as_elim]
def fixInduction' {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a : α}
    (h : b ∈ f.fix a) (hbase : ∀ a_final : α, Sum.inl b ∈ f a_final → C a_final)
    (hind : ∀ a₀ a₁ : α, b ∈ f.fix a₁ → Sum.inr a₁ ∈ f a₀ → C a₁ → C a₀) : C a 
goal: C a

full_name: PFun.fixInduction'_stop
code: theorem fixInduction'_stop {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a : α} (h : b ∈ f.fix a)
    (fa : Sum.inl b ∈ f a) (hbase : ∀ a_final : α, Sum.inl b ∈ f a_final → C a_final)
    (hind : ∀ a₀ a₁ : α, b ∈ f.fix a₁ → Sum.inr a₁ ∈ f a₀ → C a₁ → C a₀) :
    @fixInduction' _ _ C _ _ _ h hbase hind = hbase a fa 
goal: PFun.fixInduction' h hbase hind = hbase a fa

full_name: PFun.fixInduction'_fwd
code: theorem fixInduction'_fwd {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a a' : α} (h : b ∈ f.fix a)
    (h' : b ∈ f.fix a') (fa : Sum.inr a' ∈ f a)
    (hbase : ∀ a_final : α, Sum.inl b ∈ f a_final → C a_final)
    (hind : ∀ a₀ a₁ : α, b ∈ f.fix a₁ → Sum.inr a₁ ∈ f a₀ → C a₁ → C a₀) :
    @fixInduction' _ _ C _ _ _ h hbase hind = hind a a' h' fa (fixInduction' h' hbase hind) 
goal: PFun.fixInduction' h hbase hind = hind a a' h' fa (PFun.fixInduction' h' hbase hind)

full_name: PFun.image
code: /-- Image of a set under a partial function. -/
def image (s : Set α) : Set β 
goal: Set β

full_name: PFun.image_def
code: theorem image_def (s : Set α) : f.image s = { y | ∃ x ∈ s, y ∈ f x } 
goal: f.image s = {y | ∃ x ∈ s, y ∈ f x}

full_name: PFun.mem_image
code: theorem mem_image (y : β) (s : Set α) : y ∈ f.image s ↔ ∃ x ∈ s, y ∈ f x 
goal: y ∈ f.image s ↔ ∃ x ∈ s, y ∈ f x

full_name: PFun.image_mono
code: theorem image_mono {s t : Set α} (h : s ⊆ t) : f.image s ⊆ f.image t 
goal: f.image s ⊆ f.image t

full_name: PFun.image_inter
code: theorem image_inter (s t : Set α) : f.image (s ∩ t) ⊆ f.image s ∩ f.image t 
goal: f.image (s ∩ t) ⊆ f.image s ∩ f.image t

full_name: PFun.image_union
code: theorem image_union (s t : Set α) : f.image (s ∪ t) = f.image s ∪ f.image t 
goal: f.image (s ∪ t) = f.image s ∪ f.image t

full_name: PFun.preimage
code: /-- Preimage of a set under a partial function. -/
def preimage (s : Set β) : Set α 
goal: Set α

full_name: PFun.Preimage_def
code: theorem Preimage_def (s : Set β) : f.preimage s = { x | ∃ y ∈ s, y ∈ f x } 
goal: f.preimage s = {x | ∃ y ∈ s, y ∈ f x}

full_name: PFun.mem_preimage
code: @[simp]
theorem mem_preimage (s : Set β) (x : α) : x ∈ f.preimage s ↔ ∃ y ∈ s, y ∈ f x 
goal: x ∈ f.preimage s ↔ ∃ y ∈ s, y ∈ f x

full_name: PFun.preimage_subset_dom
code: theorem preimage_subset_dom (s : Set β) : f.preimage s ⊆ f.Dom 
goal: f.preimage s ⊆ f.Dom

full_name: PFun.preimage_mono
code: theorem preimage_mono {s t : Set β} (h : s ⊆ t) : f.preimage s ⊆ f.preimage t 
goal: f.preimage s ⊆ f.preimage t

full_name: PFun.preimage_inter
code: theorem preimage_inter (s t : Set β) : f.preimage (s ∩ t) ⊆ f.preimage s ∩ f.preimage t 
goal: f.preimage (s ∩ t) ⊆ f.preimage s ∩ f.preimage t

full_name: PFun.preimage_union
code: theorem preimage_union (s t : Set β) : f.preimage (s ∪ t) = f.preimage s ∪ f.preimage t 
goal: f.preimage (s ∪ t) = f.preimage s ∪ f.preimage t

full_name: PFun.preimage_univ
code: theorem preimage_univ : f.preimage Set.univ = f.Dom 
goal: f.preimage Set.univ = f.Dom

full_name: PFun.coe_preimage
code: theorem coe_preimage (f : α → β) (s : Set β) : (f : α →. β).preimage s = f ⁻¹' s 
goal: (↑f).preimage s = f ⁻¹' s

full_name: PFun.core
code: /-- Core of a set `s : Set β` with respect to a partial function `f : α →. β`. Set of all `a : α`
such that `f a ∈ s`, if `f a` is defined. -/
def core (s : Set β) : Set α 
goal: Set α

full_name: PFun.core_def
code: theorem core_def (s : Set β) : f.core s = { x | ∀ y, y ∈ f x → y ∈ s } 
goal: f.core s = {x | ∀ y ∈ f x, y ∈ s}

full_name: PFun.mem_core
code: @[simp]
theorem mem_core (x : α) (s : Set β) : x ∈ f.core s ↔ ∀ y, y ∈ f x → y ∈ s 
goal: x ∈ f.core s ↔ ∀ y ∈ f x, y ∈ s

full_name: PFun.compl_dom_subset_core
code: theorem compl_dom_subset_core (s : Set β) : f.Domᶜ ⊆ f.core s 
goal: f.Domᶜ ⊆ f.core s

full_name: PFun.core_mono
code: theorem core_mono {s t : Set β} (h : s ⊆ t) : f.core s ⊆ f.core t 
goal: f.core s ⊆ f.core t

full_name: PFun.core_inter
code: theorem core_inter (s t : Set β) : f.core (s ∩ t) = f.core s ∩ f.core t 
goal: f.core (s ∩ t) = f.core s ∩ f.core t

full_name: PFun.mem_core_res
code: theorem mem_core_res (f : α → β) (s : Set α) (t : Set β) (x : α) :
    x ∈ (res f s).core t ↔ x ∈ s → f x ∈ t 
goal: x ∈ (PFun.res f s).core t ↔ x ∈ s → f x ∈ t

full_name: PFun.core_res
code: theorem core_res (f : α → β) (s : Set α) (t : Set β) : (res f s).core t = sᶜ ∪ f ⁻¹' t 
goal: (PFun.res f s).core t = sᶜ ∪ f ⁻¹' t

full_name: PFun.core_restrict
code: theorem core_restrict (f : α → β) (s : Set β) : (f : α →. β).core s = s.preimage f 
goal: (↑f).core s = f ⁻¹' s

full_name: PFun.preimage_subset_core
code: theorem preimage_subset_core (f : α →. β) (s : Set β) : f.preimage s ⊆ f.core s 
goal: f.preimage s ⊆ f.core s

full_name: PFun.preimage_eq
code: theorem preimage_eq (f : α →. β) (s : Set β) : f.preimage s = f.core s ∩ f.Dom 
goal: f.preimage s = f.core s ∩ f.Dom

full_name: PFun.core_eq
code: theorem core_eq (f : α →. β) (s : Set β) : f.core s = f.preimage s ∪ f.Domᶜ 
goal: f.core s = f.preimage s ∪ f.Domᶜ

full_name: PFun.preimage_asSubtype
code: theorem preimage_asSubtype (f : α →. β) (s : Set β) :
    f.asSubtype ⁻¹' s = Subtype.val ⁻¹' f.preimage s 
goal: f.asSubtype ⁻¹' s = Subtype.val ⁻¹' f.preimage s

full_name: PFun.toSubtype
code: /-- Turns a function into a partial function to a subtype. -/
def toSubtype (p : β → Prop) (f : α → β) : α →. Subtype p 
goal: α →. Subtype p

full_name: PFun.dom_toSubtype
code: @[simp]
theorem dom_toSubtype (p : β → Prop) (f : α → β) : (toSubtype p f).Dom = { a | p (f a) } 
goal: (PFun.toSubtype p f).Dom = {a | p (f a)}

full_name: PFun.toSubtype_apply
code: @[simp]
theorem toSubtype_apply (p : β → Prop) (f : α → β) (a : α) :
    toSubtype p f a = ⟨p (f a), Subtype.mk _⟩ 
goal: PFun.toSubtype p f a = { Dom := p (f a), get := Subtype.mk (f a) }

full_name: PFun.dom_toSubtype_apply_iff
code: theorem dom_toSubtype_apply_iff {p : β → Prop} {f : α → β} {a : α} :
    (toSubtype p f a).Dom ↔ p (f a) 
goal: (PFun.toSubtype p f a).Dom ↔ p (f a)

full_name: PFun.mem_toSubtype_iff
code: theorem mem_toSubtype_iff {p : β → Prop} {f : α → β} {a : α} {b : Subtype p} :
    b ∈ toSubtype p f a ↔ ↑b = f a 
goal: b ∈ PFun.toSubtype p f a ↔ ↑b = f a

full_name: PFun.id
code: /-- The identity as a partial function -/
protected def id (α : Type*) : α →. α 
goal: α →. α

full_name: PFun.coe_id
code: @[simp]
theorem coe_id (α : Type*) : ((id : α → α) : α →. α) = PFun.id α 
goal: ↑id = PFun.id α

full_name: PFun.id_apply
code: @[simp]
theorem id_apply (a : α) : PFun.id α a = Part.some a 
goal: PFun.id α a = Part.some a

full_name: PFun.comp
code: /-- Composition of partial functions as a partial function. -/
def comp (f : β →. γ) (g : α →. β) : α →. γ 
goal: α →. γ

full_name: PFun.comp_apply
code: @[simp]
theorem comp_apply (f : β →. γ) (g : α →. β) (a : α) : f.comp g a = (g a).bind f 
goal: f.comp g a = (g a).bind f

full_name: PFun.id_comp
code: @[simp]
theorem id_comp (f : α →. β) : (PFun.id β).comp f = f 
goal: (PFun.id β).comp f = f

full_name: PFun.comp_id
code: @[simp]
theorem comp_id (f : α →. β) : f.comp (PFun.id α) = f 
goal: f.comp (PFun.id α) = f

full_name: PFun.dom_comp
code: @[simp]
theorem dom_comp (f : β →. γ) (g : α →. β) : (f.comp g).Dom = g.preimage f.Dom 
goal: (f.comp g).Dom = g.preimage f.Dom

full_name: PFun.preimage_comp
code: @[simp]
theorem preimage_comp (f : β →. γ) (g : α →. β) (s : Set γ) :
    (f.comp g).preimage s = g.preimage (f.preimage s) 
goal: (f.comp g).preimage s = g.preimage (f.preimage s)

full_name: PFun.Part.bind_comp
code: @[simp]
theorem Part.bind_comp (f : β →. γ) (g : α →. β) (a : Part α) :
    a.bind (f.comp g) = (a.bind g).bind f 
goal: a.bind (f.comp g) = (a.bind g).bind f

full_name: PFun.comp_assoc
code: @[simp]
theorem comp_assoc (f : γ →. δ) (g : β →. γ) (h : α →. β) : (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: PFun.coe_comp
code: theorem coe_comp (g : β → γ) (f : α → β) : ((g ∘ f : α → γ) : α →. γ) = (g : β →. γ).comp f 
goal: ↑(g ∘ f) = (↑g).comp ↑f

full_name: PFun.prodLift
code: /-- Product of partial functions. -/
def prodLift (f : α →. β) (g : α →. γ) : α →. β × γ 
goal: α →. β × γ

full_name: PFun.dom_prodLift
code: @[simp]
theorem dom_prodLift (f : α →. β) (g : α →. γ) :
    (f.prodLift g).Dom = { x | (f x).Dom ∧ (g x).Dom } 
goal: (f.prodLift g).Dom = {x | (f x).Dom ∧ (g x).Dom}

full_name: PFun.get_prodLift
code: theorem get_prodLift (f : α →. β) (g : α →. γ) (x : α) (h) :
    (f.prodLift g x).get h = ((f x).get h.1, (g x).get h.2) 
goal: (f.prodLift g x).get h = ((f x).get ⋯, (g x).get ⋯)

full_name: PFun.prodLift_apply
code: @[simp]
theorem prodLift_apply (f : α →. β) (g : α →. γ) (x : α) :
    f.prodLift g x = ⟨(f x).Dom ∧ (g x).Dom, fun h => ((f x).get h.1, (g x).get h.2)⟩ 
goal: f.prodLift g x = { Dom := (f x).Dom ∧ (g x).Dom, get := fun h => ((f x).get ⋯, (g x).get ⋯) }

full_name: PFun.mem_prodLift
code: theorem mem_prodLift {f : α →. β} {g : α →. γ} {x : α} {y : β × γ} :
    y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x 
goal: y ∈ f.prodLift g x ↔ y.1 ∈ f x ∧ y.2 ∈ g x

full_name: PFun.prodMap
code: /-- Product of partial functions. -/
def prodMap (f : α →. γ) (g : β →. δ) : α × β →. γ × δ 
goal: α × β →. γ × δ

full_name: PFun.dom_prodMap
code: @[simp]
theorem dom_prodMap (f : α →. γ) (g : β →. δ) :
    (f.prodMap g).Dom = { x | (f x.1).Dom ∧ (g x.2).Dom } 
goal: (f.prodMap g).Dom = {x | (f x.1).Dom ∧ (g x.2).Dom}

full_name: PFun.get_prodMap
code: theorem get_prodMap (f : α →. γ) (g : β →. δ) (x : α × β) (h) :
    (f.prodMap g x).get h = ((f x.1).get h.1, (g x.2).get h.2) 
goal: (f.prodMap g x).get h = ((f x.1).get ⋯, (g x.2).get ⋯)

full_name: PFun.prodMap_apply
code: @[simp]
theorem prodMap_apply (f : α →. γ) (g : β →. δ) (x : α × β) :
    f.prodMap g x = ⟨(f x.1).Dom ∧ (g x.2).Dom, fun h => ((f x.1).get h.1, (g x.2).get h.2)⟩ 
goal: f.prodMap g x = { Dom := (f x.1).Dom ∧ (g x.2).Dom, get := fun h => ((f x.1).get ⋯, (g x.2).get ⋯) }

full_name: PFun.mem_prodMap
code: theorem mem_prodMap {f : α →. γ} {g : β →. δ} {x : α × β} {y : γ × δ} :
    y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2 
goal: y ∈ f.prodMap g x ↔ y.1 ∈ f x.1 ∧ y.2 ∈ g x.2

full_name: PFun.prodLift_fst_comp_snd_comp
code: @[simp]
theorem prodLift_fst_comp_snd_comp (f : α →. γ) (g : β →. δ) :
    prodLift (f.comp ((Prod.fst : α × β → α) : α × β →. α))
        (g.comp ((Prod.snd : α × β → β) : α × β →. β)) =
      prodMap f g 
goal: (f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) = f.prodMap g

full_name: PFun.prodMap_id_id
code: @[simp]
theorem prodMap_id_id : (PFun.id α).prodMap (PFun.id β) = PFun.id _ 
goal: (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β)

full_name: PFun.prodMap_comp_comp
code: @[simp]
theorem prodMap_comp_comp (f₁ : α →. β) (f₂ : β →. γ) (g₁ : δ →. ε) (g₂ : ε →. ι) :
    (f₂.comp f₁).prodMap (g₂.comp g₁) = (f₂.prodMap g₂).comp (f₁.prodMap g₁) 
goal: (f₂.comp f₁).prodMap (g₂.comp g₁) = (f₂.prodMap g₂).comp (f₁.prodMap g₁)