fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
listFilter (hf : PrimrecPred p) : Primrec fun L ↦ List.filter (p ·) L := by
rw [← List.filterMap_eq_filter]
apply listFilterMap .id
simp only [Primrec₂, Option.guard, decide_eq_true_eq]
exact ite (hf.comp snd) (option_some_iff.mpr snd) (const none) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | listFilter | Filtering a list for elements that satisfy a decidable predicate is primitive recursive. |
list_findIdx {f : α → List β} {p : α → β → Bool}
(hf : Primrec f) (hp : Primrec₂ p) : Primrec fun a => (f a).findIdx (p a) :=
(list_foldr hf (const 0) <|
to₂ <| cond (hp.comp fst <| fst.comp snd) (const 0) (succ.comp <| snd.comp snd)).of_eq
fun a => by dsimp; induction f a <;> simp [List.findIdx_cons,... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_findIdx | null |
list_idxOf [DecidableEq α] : Primrec₂ (@List.idxOf α _) :=
to₂ <| list_findIdx snd <| Primrec.beq.comp₂ snd.to₂ (fst.comp fst).to₂ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_idxOf | null |
nat_strong_rec (f : α → ℕ → σ) {g : α → List σ → Option σ} (hg : Primrec₂ g)
(H : ∀ a n, g a ((List.range n).map (f a)) = some (f a n)) : Primrec₂ f :=
suffices Primrec₂ fun a n => (List.range n).map (f a) from
Primrec₂.option_some_iff.1 <|
(list_getElem?.comp (this.comp fst (succ.comp snd)) snd).to₂.of... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_strong_rec | null |
listLookup [DecidableEq α] : Primrec₂ (List.lookup : α → List (α × β) → Option β) :=
(to₂ <| list_rec snd (const none) <|
to₂ <|
cond (Primrec.beq.comp (fst.comp fst) (fst.comp <| fst.comp snd))
(option_some.comp <| snd.comp <| fst.comp snd)
(snd.comp <| snd.comp snd)).of_eq
fun a ps => by... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | listLookup | null |
nat_omega_rec' (f : β → σ) {m : β → ℕ} {l : β → List β} {g : β → List σ → Option σ}
(hm : Primrec m) (hl : Primrec l) (hg : Primrec₂ g)
(Ord : ∀ b, ∀ b' ∈ l b, m b' < m b)
(H : ∀ b, g b ((l b).map f) = some (f b)) : Primrec f := by
haveI : DecidableEq β := Encodable.decidableEqOfEncodable β
let mapGraph... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_omega_rec' | null |
nat_omega_rec (f : α → β → σ) {m : α → β → ℕ}
{l : α → β → List β} {g : α → β × List σ → Option σ}
(hm : Primrec₂ m) (hl : Primrec₂ l) (hg : Primrec₂ g)
(Ord : ∀ a b, ∀ b' ∈ l a b, m a b' < m a b)
(H : ∀ a b, g a (b, (l a b).map (f a)) = some (f a b)) : Primrec₂ f :=
Primrec₂.uncurry.mp <|
nat_ome... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_omega_rec | null |
exists_mem_list : (hf : PrimrecPred p) → PrimrecPred fun L : List α ↦ ∃ a ∈ L, p a
| ⟨_, hf⟩ => .of_eq
(.not <| Primrec.eq.comp (list_length.comp <| listFilter hf.primrecPred) (const 0)) <| by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | exists_mem_list | Checking if any element of a list satisfies a decidable predicate is primitive recursive. |
forall_mem_list : (hf : PrimrecPred p) → PrimrecPred fun L : List α ↦ ∀ a ∈ L, p a
| ⟨_, hf⟩ => .of_eq
(Primrec.eq.comp (list_length.comp <| listFilter hf.primrecPred) (list_length)) <| by simp
variable {p : ℕ → Prop} | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | forall_mem_list | Checking if every element of a list satisfies a decidable predicate is primitive recursive. |
exists_lt (hf : PrimrecPred p) : PrimrecPred fun n ↦ ∃ x < n, p x :=
of_eq (hf.exists_mem_list.comp list_range) (by simp) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | exists_lt | Bounded existential quantifiers are primitive recursive. |
forall_lt (hf : PrimrecPred p) : PrimrecPred fun n ↦ ∀ x < n, p x :=
of_eq (hf.forall_mem_list.comp list_range) (by simp) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | forall_lt | Bounded universal quantifiers are primitive recursive. |
listFilter_listRange {R : ℕ → ℕ → Prop} (s : ℕ) [DecidableRel R] (hf : PrimrecRel R) :
Primrec fun n ↦ (range s).filter (fun y ↦ R y n) := by
simp only [← filterMap_eq_filter]
refine listFilterMap (.const (range s)) ?_
refine ite (Primrec.eq.comp ?_ (const true)) (option_some_iff.mpr snd) (.const Option.none)... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | listFilter_listRange | A helper lemma for proofs about bounded quantifiers on decidable relations. |
protected not (hf : PrimrecRel R) : PrimrecRel fun a b ↦ ¬ R a b := PrimrecPred.not hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | not | null |
listFilter (hf : PrimrecRel R) [DecidableRel R] :
Primrec₂ fun (L : List α) b ↦ L.filter (fun a ↦ R a b) := by
simp only [← List.filterMap_eq_filter]
refine listFilterMap fst (Primrec.ite ?_ ?_ (Primrec.const Option.none))
· exact Primrec.eq.comp (hf.decide.comp snd (snd.comp fst)) (.const true)
· exact (op... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | listFilter | If `R a b` is decidable, then given `L : List α` and `b : β`, it is primitive recursive
to filter `L` for elements `a` with `R a b` |
exists_mem_list (hf : PrimrecRel R) : PrimrecRel fun (L : List α) b ↦ ∃ a ∈ L, R a b := by
classical
have h (L) (b) : (List.filter (R · b) L).length ≠ 0 ↔ ∃ a ∈ L, R a b := by simp
refine .of_eq (.not ?_) h
exact Primrec.eq.comp (list_length.comp hf.listFilter) (const 0) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | exists_mem_list | If `R a b` is decidable, then given `L : List α` and `b : β`, `g L b ↔ ∃ a L, R a b`
is a primitive recursive relation. |
forall_mem_list (hf : PrimrecRel R) : PrimrecRel fun (L : List α) b ↦ ∀ a ∈ L, R a b := by
classical
have h (L) (b) : (List.filter (R · b) L).length = L.length ↔ ∀ a ∈ L, R a b := by simp
apply PrimrecRel.of_eq ?_ h
exact (Primrec.eq.comp (list_length.comp <| PrimrecRel.listFilter hf) (.comp list_length fst))
v... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | forall_mem_list | If `R a b` is decidable, then given `L : List α` and `b : β`, `g L b ↔ ∀ a L, R a b`
is a primitive recursive relation. |
exists_lt (hf : PrimrecRel R) : PrimrecRel fun n y ↦ ∃ x < n, R x y :=
(hf.exists_mem_list.comp (list_range.comp fst) snd).of_eq (by simp) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | exists_lt | If `R a b` is decidable, then for any fixed `n` and `y`, `g n y ↔ ∃ x < n, R x y` is a
primitive recursive relation. |
forall_lt (hf : PrimrecRel R) : PrimrecRel fun n y ↦ ∀ x < n, R x y :=
(hf.forall_mem_list.comp (list_range.comp fst) snd).of_eq (by simp) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | forall_lt | If `R a b` is decidable, then for any fixed `n` and `y`, `g n y ↔ ∀ x < n, R x y` is a
primitive recursive relation. |
subtype {p : α → Prop} [DecidablePred p] (hp : PrimrecPred p) : Primcodable (Subtype p) :=
⟨have : Primrec fun n => (@decode α _ n).bind fun a => Option.guard p a :=
option_bind .decode (option_guard (hp.comp snd).primrecRel snd)
nat_iff.1 <| (encode_iff.2 this).of_eq fun n =>
show _ = encode ((@decode α _ ... | def | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | subtype | A subtype of a primitive recursive predicate is `Primcodable`. |
fin {n} : Primcodable (Fin n) :=
@ofEquiv _ _ (subtype <| nat_lt.comp .id (const n)) Fin.equivSubtype | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin | null |
vector {n} : Primcodable (List.Vector α n) :=
subtype ((@Primrec.eq ℕ _).comp list_length (const _)) | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector | null |
finArrow {n} : Primcodable (Fin n → α) :=
ofEquiv _ (Equiv.vectorEquivFin _ _).symm | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | finArrow | null |
mem_range_encode : PrimrecPred (fun n => n ∈ Set.range (encode : α → ℕ)) :=
have : PrimrecPred fun n => Encodable.decode₂ α n ≠ none :=
.not
(Primrec.eq.comp
(.option_bind .decode
(.ite (by simpa using Primrec.eq.comp (Primrec.encode.comp .snd) .fst)
(Primrec.option_some.comp .... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | mem_range_encode | null |
ulower : Primcodable (ULower α) :=
Primcodable.subtype mem_range_encode | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | ulower | null |
subtype_val {p : α → Prop} [DecidablePred p] {hp : PrimrecPred p} :
haveI := Primcodable.subtype hp
Primrec (@Subtype.val α p) := by
letI := Primcodable.subtype hp
refine (Primcodable.prim (Subtype p)).of_eq fun n => ?_
rcases @decode (Subtype p) _ n with (_ | ⟨a, h⟩) <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | subtype_val | null |
subtype_val_iff {p : β → Prop} [DecidablePred p] {hp : PrimrecPred p} {f : α → Subtype p} :
haveI := Primcodable.subtype hp
(Primrec fun a => (f a).1) ↔ Primrec f := by
letI := Primcodable.subtype hp
refine ⟨fun h => ?_, fun hf => subtype_val.comp hf⟩
refine Nat.Primrec.of_eq h fun n => ?_
rcases @decod... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | subtype_val_iff | null |
subtype_mk {p : β → Prop} [DecidablePred p] {hp : PrimrecPred p} {f : α → β}
{h : ∀ a, p (f a)} (hf : Primrec f) :
haveI := Primcodable.subtype hp
Primrec fun a => @Subtype.mk β p (f a) (h a) :=
subtype_val_iff.1 hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | subtype_mk | null |
option_get {f : α → Option β} {h : ∀ a, (f a).isSome} :
Primrec f → Primrec fun a => (f a).get (h a) := by
intro hf
refine (Nat.Primrec.pred.comp hf).of_eq fun n => ?_
generalize hx : @decode α _ n = x
cases x <;> simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_get | null |
ulower_down : Primrec (ULower.down : α → ULower α) :=
letI : ∀ a, Decidable (a ∈ Set.range (encode : α → ℕ)) := decidableRangeEncode _
subtype_mk .encode | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | ulower_down | null |
ulower_up : Primrec (ULower.up : ULower α → α) :=
letI : ∀ a, Decidable (a ∈ Set.range (encode : α → ℕ)) := decidableRangeEncode _
option_get (Primrec.decode₂.comp subtype_val) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | ulower_up | null |
fin_val_iff {n} {f : α → Fin n} : (Primrec fun a => (f a).1) ↔ Primrec f := by
letI : Primcodable { a // id a < n } := Primcodable.subtype (nat_lt.comp .id (const _))
exact (Iff.trans (by rfl) subtype_val_iff).trans (of_equiv_iff _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_val_iff | null |
fin_val {n} : Primrec (fun (i : Fin n) => (i : ℕ)) :=
fin_val_iff.2 .id | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_val | null |
fin_succ {n} : Primrec (@Fin.succ n) :=
fin_val_iff.1 <| by simp [succ.comp fin_val] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_succ | null |
vector_toList {n} : Primrec (@List.Vector.toList α n) :=
subtype_val | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_toList | null |
vector_toList_iff {n} {f : α → List.Vector β n} :
(Primrec fun a => (f a).toList) ↔ Primrec f :=
subtype_val_iff | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_toList_iff | null |
vector_cons {n} : Primrec₂ (@List.Vector.cons α n) :=
vector_toList_iff.1 <| by simpa using list_cons.comp fst (vector_toList_iff.2 snd) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_cons | null |
vector_length {n} : Primrec (@List.Vector.length α n) :=
const _ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_length | null |
vector_head {n} : Primrec (@List.Vector.head α n) :=
option_some_iff.1 <| (list_head?.comp vector_toList).of_eq fun ⟨_ :: _, _⟩ => rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_head | null |
vector_tail {n} : Primrec (@List.Vector.tail α n) :=
vector_toList_iff.1 <| (list_tail.comp vector_toList).of_eq fun ⟨l, h⟩ => by cases l <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_tail | null |
vector_get {n} : Primrec₂ (@List.Vector.get α n) :=
option_some_iff.1 <|
(list_getElem?.comp (vector_toList.comp fst) (fin_val.comp snd)).of_eq fun a => by
simp [Vector.get_eq_get_toList] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_get | null |
list_ofFn :
∀ {n} {f : Fin n → α → σ}, (∀ i, Primrec (f i)) → Primrec fun a => List.ofFn fun i => f i a
| 0, _, _ => by simp only [List.ofFn_zero]; exact const []
| n + 1, f, hf => by
simpa using list_cons.comp (hf 0) (list_ofFn fun i => hf i.succ) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_ofFn | null |
vector_ofFn {n} {f : Fin n → α → σ} (hf : ∀ i, Primrec (f i)) :
Primrec fun a => List.Vector.ofFn fun i => f i a :=
vector_toList_iff.1 <| by simp [list_ofFn hf] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_ofFn | null |
vector_get' {n} : Primrec (@List.Vector.get α n) :=
of_equiv_symm | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_get' | null |
vector_ofFn' {n} : Primrec (@List.Vector.ofFn α n) :=
of_equiv | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vector_ofFn' | null |
fin_app {n} : Primrec₂ (@id (Fin n → σ)) :=
(vector_get.comp (vector_ofFn'.comp fst) snd).of_eq fun ⟨v, i⟩ => by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_app | null |
fin_curry₁ {n} {f : Fin n → α → σ} : Primrec₂ f ↔ ∀ i, Primrec (f i) :=
⟨fun h i => h.comp (const i) .id, fun h =>
(vector_get.comp ((vector_ofFn h).comp snd) fst).of_eq fun a => by simp⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_curry₁ | null |
fin_curry {n} {f : α → Fin n → σ} : Primrec f ↔ Primrec₂ f :=
⟨fun h => fin_app.comp (h.comp fst) snd, fun h =>
(vector_get'.comp
(vector_ofFn fun i => show Primrec fun a => f a i from h.comp .id (const i))).of_eq
fun a => by funext i; simp⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | fin_curry | null |
Primrec' : ∀ {n}, (List.Vector ℕ n → ℕ) → Prop
| zero : @Primrec' 0 fun _ => 0
| succ : @Primrec' 1 fun v => succ v.head
| get {n} (i : Fin n) : Primrec' fun v => v.get i
| comp {m n f} (g : Fin n → List.Vector ℕ m → ℕ) :
Primrec' f → (∀ i, Primrec' (g i)) → Primrec' fun a => f (List.Vector.ofFn fun i => ... | inductive | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Primrec' | An alternative inductive definition of `Primrec` which
does not use the pairing function on ℕ, and so has to
work with n-ary functions on ℕ instead of unary functions.
We prove that this is equivalent to the regular notion
in `to_prim` and `of_prim`. |
to_prim {n f} (pf : @Nat.Primrec' n f) : Primrec f := by
induction pf with
| zero => exact .const 0
| succ => exact _root_.Primrec.succ.comp .vector_head
| get i => exact Primrec.vector_get.comp .id (.const i)
| comp _ _ _ hf hg => exact hf.comp (.vector_ofFn fun i => hg i)
| @prec n f g _ _ hf hg =>
ex... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | to_prim | null |
of_eq {n} {f g : List.Vector ℕ n → ℕ} (hf : Primrec' f) (H : ∀ i, f i = g i) :
Primrec' g :=
(funext H : f = g) ▸ hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | of_eq | null |
const {n} : ∀ m, @Primrec' n fun _ => m
| 0 => zero.comp Fin.elim0 fun i => i.elim0
| m + 1 => succ.comp _ fun _ => const m | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | const | null |
head {n : ℕ} : @Primrec' n.succ head :=
(get 0).of_eq fun v => by simp [get_zero] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | head | null |
tail {n f} (hf : @Primrec' n f) : @Primrec' n.succ fun v => f v.tail :=
(hf.comp _ fun i => @get _ i.succ).of_eq fun v => by
rw [← ofFn_get v.tail]; congr; funext i; simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | tail | null |
Vec {n m} (f : List.Vector ℕ n → List.Vector ℕ m) : Prop :=
∀ i, Primrec' fun v => (f v).get i | def | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Vec | A function from vectors to vectors is primitive recursive when all of its projections are. |
protected nil {n} : @Vec n 0 fun _ => nil := fun i => i.elim0 | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nil | null |
protected cons {n m f g} (hf : @Primrec' n f) (hg : @Vec n m g) :
Vec fun v => f v ::ᵥ g v := fun i => Fin.cases (by simp [*]) (fun i => by simp [hg i]) i | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | cons | null |
idv {n} : @Vec n n id :=
get | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | idv | null |
comp' {n m f g} (hf : @Primrec' m f) (hg : @Vec n m g) : Primrec' fun v => f (g v) :=
(hf.comp _ hg).of_eq fun v => by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | comp' | null |
comp₁ (f : ℕ → ℕ) (hf : @Primrec' 1 fun v => f v.head) {n g} (hg : @Primrec' n g) :
Primrec' fun v => f (g v) :=
hf.comp _ fun _ => hg | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | comp₁ | null |
comp₂ (f : ℕ → ℕ → ℕ) (hf : @Primrec' 2 fun v => f v.head v.tail.head) {n g h}
(hg : @Primrec' n g) (hh : @Primrec' n h) : Primrec' fun v => f (g v) (h v) := by
simpa using hf.comp' (hg.cons <| hh.cons Primrec'.nil) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | comp₂ | null |
prec' {n f g h} (hf : @Primrec' n f) (hg : @Primrec' n g) (hh : @Primrec' (n + 2) h) :
@Primrec' n fun v => (f v).rec (g v) fun y IH : ℕ => h (y ::ᵥ IH ::ᵥ v) := by
simpa using comp' (prec hg hh) (hf.cons idv) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | prec' | null |
pred : @Primrec' 1 fun v => v.head.pred :=
(prec' head (const 0) head).of_eq fun v => by simp; cases v.head <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | pred | null |
add : @Primrec' 2 fun v => v.head + v.tail.head :=
(prec head (succ.comp₁ _ (tail head))).of_eq fun v => by
simp; induction v.head <;> simp [*, Nat.succ_add] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | add | null |
sub : @Primrec' 2 fun v => v.head - v.tail.head := by
have : @Primrec' 2 fun v ↦ (fun a b ↦ b - a) v.head v.tail.head := by
refine (prec head (pred.comp₁ _ (tail head))).of_eq fun v => ?_
simp; induction v.head <;> simp [*, Nat.sub_add_eq]
simpa using comp₂ (fun a b => b - a) this (tail head) head | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sub | null |
mul : @Primrec' 2 fun v => v.head * v.tail.head :=
(prec (const 0) (tail (add.comp₂ _ (tail head) head))).of_eq fun v => by
simp; induction v.head <;> simp [*, Nat.succ_mul]; rw [add_comm] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | mul | null |
if_lt {n a b f g} (ha : @Primrec' n a) (hb : @Primrec' n b) (hf : @Primrec' n f)
(hg : @Primrec' n g) : @Primrec' n fun v => if a v < b v then f v else g v :=
(prec' (sub.comp₂ _ hb ha) hg (tail <| tail hf)).of_eq fun v => by
cases e : b v - a v
· simp [not_lt.2 (Nat.sub_eq_zero_iff_le.mp e)]
· simp [... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | if_lt | null |
natPair : @Primrec' 2 fun v => v.head.pair v.tail.head :=
if_lt head (tail head) (add.comp₂ _ (tail <| mul.comp₂ _ head head) head)
(add.comp₂ _ (add.comp₂ _ (mul.comp₂ _ head head) head) (tail head)) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | natPair | null |
protected encode : ∀ {n}, @Primrec' n encode
| 0 => (const 0).of_eq fun v => by rw [v.eq_nil]; rfl
| _ + 1 =>
(succ.comp₁ _ (natPair.comp₂ _ head (tail Primrec'.encode))).of_eq fun ⟨_ :: _, _⟩ => rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | encode | null |
sqrt : @Primrec' 1 fun v => v.head.sqrt := by
suffices H : ∀ n : ℕ, n.sqrt =
n.rec 0 fun x y => if x.succ < y.succ * y.succ then y else y.succ by
simp only [H, succ_eq_add_one]
have :=
@prec' 1 _ _
(fun v => by
have x := v.head; have y := v.tail.head
exact if x.succ < y... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sqrt | null |
unpair₁ {n f} (hf : @Primrec' n f) : @Primrec' n fun v => (f v).unpair.1 := by
have s := sqrt.comp₁ _ hf
have fss := sub.comp₂ _ hf (mul.comp₂ _ s s)
refine (if_lt fss s fss s).of_eq fun v => ?_
simp [Nat.unpair]; split_ifs <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | unpair₁ | null |
unpair₂ {n f} (hf : @Primrec' n f) : @Primrec' n fun v => (f v).unpair.2 := by
have s := sqrt.comp₁ _ hf
have fss := sub.comp₂ _ hf (mul.comp₂ _ s s)
refine (if_lt fss s s (sub.comp₂ _ fss s)).of_eq fun v => ?_
simp [Nat.unpair]; split_ifs <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | unpair₂ | null |
of_prim {n f} : Primrec f → @Primrec' n f :=
suffices ∀ f, Nat.Primrec f → @Primrec' 1 fun v => f v.head from fun hf =>
(pred.comp₁ _ <|
(this _ hf).comp₁ (fun m => Encodable.encode <| (@decode (List.Vector ℕ n) _ m).map f)
Primrec'.encode).of_eq
fun i => by simp [encodek]
fun f hf =... | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | of_prim | null |
prim_iff {n f} : @Primrec' n f ↔ Primrec f :=
⟨to_prim, of_prim⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | prim_iff | null |
prim_iff₁ {f : ℕ → ℕ} : (@Primrec' 1 fun v => f v.head) ↔ Primrec f :=
prim_iff.trans
⟨fun h => (h.comp <| .vector_ofFn fun _ => .id).of_eq fun v => by simp, fun h =>
h.comp .vector_head⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | prim_iff₁ | null |
prim_iff₂ {f : ℕ → ℕ → ℕ} : (@Primrec' 2 fun v => f v.head v.tail.head) ↔ Primrec₂ f :=
prim_iff.trans
⟨fun h => (h.comp <| Primrec.vector_cons.comp .fst <|
Primrec.vector_cons.comp .snd (.const nil)).of_eq fun v => by simp,
fun h => h.comp .vector_head (Primrec.vector_head.comp .vector_tail)⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | prim_iff₂ | null |
vec_iff {m n f} : @Vec m n f ↔ Primrec f :=
⟨fun h => by simpa using Primrec.vector_ofFn fun i => to_prim (h i), fun h i =>
of_prim <| Primrec.vector_get.comp h (.const i)⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | vec_iff | null |
Primrec.nat_sqrt : Primrec Nat.sqrt :=
Nat.Primrec'.prim_iff₁.1 Nat.Primrec'.sqrt
set_option linter.style.longFile 1700 | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Primrec.nat_sqrt | null |
ManyOneReducible {α β} [Primcodable α] [Primcodable β] (p : α → Prop) (q : β → Prop) :=
∃ f, Computable f ∧ ∀ a, p a ↔ q (f a)
@[inherit_doc ManyOneReducible]
infixl:1000 " ≤₀ " => ManyOneReducible | def | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneReducible | `p` is many-one reducible to `q` if there is a computable function translating questions about `p`
to questions about `q`. |
ManyOneReducible.mk {α β} [Primcodable α] [Primcodable β] {f : α → β} (q : β → Prop)
(h : Computable f) : (fun a => q (f a)) ≤₀ q :=
⟨f, h, fun _ => Iff.rfl⟩
@[refl] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneReducible.mk | null |
manyOneReducible_refl {α} [Primcodable α] (p : α → Prop) : p ≤₀ p :=
⟨id, Computable.id, by simp⟩
@[trans] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | manyOneReducible_refl | null |
ManyOneReducible.trans {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop} : p ≤₀ q → q ≤₀ r → p ≤₀ r
| ⟨f, c₁, h₁⟩, ⟨g, c₂, h₂⟩ =>
⟨g ∘ f, c₂.comp c₁,
fun a => ⟨fun h => by rw [comp_apply, ← h₂, ← h₁]; assumption, fun h => by rwa [h₁, h₂]⟩⟩ | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneReducible.trans | null |
reflexive_manyOneReducible {α} [Primcodable α] : Reflexive (@ManyOneReducible α α _ _) :=
manyOneReducible_refl | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | reflexive_manyOneReducible | null |
transitive_manyOneReducible {α} [Primcodable α] : Transitive (@ManyOneReducible α α _ _) :=
fun _ _ _ => ManyOneReducible.trans | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | transitive_manyOneReducible | null |
OneOneReducible {α β} [Primcodable α] [Primcodable β] (p : α → Prop) (q : β → Prop) :=
∃ f, Computable f ∧ Injective f ∧ ∀ a, p a ↔ q (f a)
@[inherit_doc OneOneReducible]
infixl:1000 " ≤₁ " => OneOneReducible | def | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible | `p` is one-one reducible to `q` if there is an injective computable function translating questions
about `p` to questions about `q`. |
OneOneReducible.mk {α β} [Primcodable α] [Primcodable β] {f : α → β} (q : β → Prop)
(h : Computable f) (i : Injective f) : (fun a => q (f a)) ≤₁ q :=
⟨f, h, i, fun _ => Iff.rfl⟩
@[refl] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible.mk | null |
oneOneReducible_refl {α} [Primcodable α] (p : α → Prop) : p ≤₁ p :=
⟨id, Computable.id, injective_id, by simp⟩
@[trans] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | oneOneReducible_refl | null |
OneOneReducible.trans {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop}
{q : β → Prop} {r : γ → Prop} : p ≤₁ q → q ≤₁ r → p ≤₁ r
| ⟨f, c₁, i₁, h₁⟩, ⟨g, c₂, i₂, h₂⟩ =>
⟨g ∘ f, c₂.comp c₁, i₂.comp i₁, fun a =>
⟨fun h => by rw [comp_apply, ← h₂, ← h₁]; assumption, fun h => by rwa [h₁, ... | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible.trans | null |
OneOneReducible.to_many_one {α β} [Primcodable α] [Primcodable β] {p : α → Prop}
{q : β → Prop} : p ≤₁ q → p ≤₀ q
| ⟨f, c, _, h⟩ => ⟨f, c, h⟩ | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible.to_many_one | null |
OneOneReducible.of_equiv {α β} [Primcodable α] [Primcodable β] {e : α ≃ β} (q : β → Prop)
(h : Computable e) : (q ∘ e) ≤₁ q :=
OneOneReducible.mk _ h e.injective | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible.of_equiv | null |
OneOneReducible.of_equiv_symm {α β} [Primcodable α] [Primcodable β] {e : α ≃ β}
(q : β → Prop) (h : Computable e.symm) : q ≤₁ (q ∘ e) := by
convert OneOneReducible.of_equiv _ h; funext; simp | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneReducible.of_equiv_symm | null |
reflexive_oneOneReducible {α} [Primcodable α] : Reflexive (@OneOneReducible α α _ _) :=
oneOneReducible_refl | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | reflexive_oneOneReducible | null |
transitive_oneOneReducible {α} [Primcodable α] : Transitive (@OneOneReducible α α _ _) :=
fun _ _ _ => OneOneReducible.trans | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | transitive_oneOneReducible | null |
computable_of_manyOneReducible {p : α → Prop} {q : β → Prop} (h₁ : p ≤₀ q)
(h₂ : ComputablePred q) : ComputablePred p := by
rcases h₁ with ⟨f, c, hf⟩
rw [show p = fun a => q (f a) from Set.ext hf]
rcases computable_iff.1 h₂ with ⟨g, hg, rfl⟩
exact ⟨by infer_instance, by simpa using hg.comp c⟩ | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | computable_of_manyOneReducible | null |
computable_of_oneOneReducible {p : α → Prop} {q : β → Prop} (h : p ≤₁ q) :
ComputablePred q → ComputablePred p :=
computable_of_manyOneReducible h.to_many_one | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | computable_of_oneOneReducible | null |
ManyOneEquiv {α β} [Primcodable α] [Primcodable β] (p : α → Prop) (q : β → Prop) :=
p ≤₀ q ∧ q ≤₀ p | def | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneEquiv | `p` and `q` are many-one equivalent if each one is many-one reducible to the other. |
OneOneEquiv {α β} [Primcodable α] [Primcodable β] (p : α → Prop) (q : β → Prop) :=
p ≤₁ q ∧ q ≤₁ p
@[refl] | def | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | OneOneEquiv | `p` and `q` are one-one equivalent if each one is one-one reducible to the other. |
manyOneEquiv_refl {α} [Primcodable α] (p : α → Prop) : ManyOneEquiv p p :=
⟨manyOneReducible_refl _, manyOneReducible_refl _⟩
@[symm] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | manyOneEquiv_refl | null |
ManyOneEquiv.symm {α β} [Primcodable α] [Primcodable β] {p : α → Prop} {q : β → Prop} :
ManyOneEquiv p q → ManyOneEquiv q p :=
And.symm
@[trans] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneEquiv.symm | null |
ManyOneEquiv.trans {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop}
{q : β → Prop} {r : γ → Prop} : ManyOneEquiv p q → ManyOneEquiv q r → ManyOneEquiv p r
| ⟨pq, qp⟩, ⟨qr, rq⟩ => ⟨pq.trans qr, rq.trans qp⟩ | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | ManyOneEquiv.trans | null |
equivalence_of_manyOneEquiv {α} [Primcodable α] : Equivalence (@ManyOneEquiv α α _ _) :=
⟨manyOneEquiv_refl, fun {_ _} => ManyOneEquiv.symm, fun {_ _ _} => ManyOneEquiv.trans⟩
@[refl] | theorem | Computability | [
"Mathlib.Computability.Halting"
] | Mathlib/Computability/Reduce.lean | equivalence_of_manyOneEquiv | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.