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 ⌀ |
|---|---|---|---|---|---|---|
Primrec₂.comp₂ {f : γ → δ → σ} {g : α → β → γ} {h : α → β → δ} (hf : Primrec₂ f)
(hg : Primrec₂ g) (hh : Primrec₂ h) : Primrec₂ fun a b => f (g a b) (h a b) :=
hf.comp hg hh | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Primrec₂.comp₂ | null |
protected PrimrecPred.decide {p : α → Prop} [DecidablePred p] (hp : PrimrecPred p) :
Primrec (fun a => decide (p a)) := by
convert hp.choose_spec | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecPred.decide | null |
Primrec.primrecPred {p : α → Prop} [DecidablePred p]
(hp : Primrec (fun a => decide (p a))) : PrimrecPred p :=
⟨inferInstance, hp⟩ | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Primrec.primrecPred | null |
primrecPred_iff_primrec_decide {p : α → Prop} [DecidablePred p] :
PrimrecPred p ↔ Primrec (fun a => decide (p a)) where
mp := PrimrecPred.decide
mpr := Primrec.primrecPred | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | primrecPred_iff_primrec_decide | null |
PrimrecPred.comp {p : β → Prop} {f : α → β} :
(hp : PrimrecPred p) → (hf : Primrec f) → PrimrecPred fun a => p (f a)
| ⟨_i, hp⟩, hf => hp.comp hf |>.primrecPred | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecPred.comp | null |
protected PrimrecRel.decide {R : α → β → Prop} [DecidableRel R] (hR : PrimrecRel R) :
Primrec₂ (fun a b => decide (R a b)) :=
PrimrecPred.decide hR | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecRel.decide | null |
Primrec₂.primrecRel {R : α → β → Prop} [DecidableRel R]
(hp : Primrec₂ (fun a b => decide (R a b))) : PrimrecRel R :=
Primrec.primrecPred hp | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | Primrec₂.primrecRel | null |
primrecRel_iff_primrec_decide {R : α → β → Prop} [DecidableRel R] :
PrimrecRel R ↔ Primrec₂ (fun a b => decide (R a b)) where
mp := PrimrecRel.decide
mpr := Primrec₂.primrecRel | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | primrecRel_iff_primrec_decide | null |
PrimrecRel.comp {R : β → γ → Prop} {f : α → β} {g : α → γ}
(hR : PrimrecRel R) (hf : Primrec f) (hg : Primrec g) : PrimrecPred fun a => R (f a) (g a) :=
PrimrecPred.comp hR (hf.pair hg) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecRel.comp | null |
PrimrecRel.comp₂ {R : γ → δ → Prop} {f : α → β → γ} {g : α → β → δ} :
PrimrecRel R → Primrec₂ f → Primrec₂ g → PrimrecRel fun a b => R (f a b) (g a b) :=
PrimrecRel.comp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecRel.comp₂ | null |
PrimrecPred.of_eq {α} [Primcodable α] {p q : α → Prop}
(hp : PrimrecPred p) (H : ∀ a, p a ↔ q a) : PrimrecPred q :=
funext (fun a => propext (H a)) ▸ hp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecPred.of_eq | null |
PrimrecRel.of_eq {α β} [Primcodable α] [Primcodable β] {r s : α → β → Prop}
(hr : PrimrecRel r) (H : ∀ a b, r a b ↔ s a b) : PrimrecRel s :=
funext₂ (fun a b => propext (H a b)) ▸ hr | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecRel.of_eq | null |
protected swap {f : α → β → σ} (h : Primrec₂ f) : Primrec₂ (swap f) :=
h.comp₂ Primrec₂.right Primrec₂.left | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | swap | null |
protected _root_.PrimrecRel.swap {r : α → β → Prop} (h : PrimrecRel r) :
PrimrecRel (swap r) :=
h.comp₂ Primrec₂.right Primrec₂.left | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | _root_.PrimrecRel.swap | null |
nat_iff {f : α → β → σ} : Primrec₂ f ↔ Nat.Primrec
(.unpaired fun m n => encode <| (@decode α _ m).bind fun a => (@decode β _ n).map (f a)) := by
have :
∀ (a : Option α) (b : Option β),
Option.map (fun p : α × β => f p.1 p.2)
(Option.bind a fun a : α => Option.map (Prod.mk a) b) =
Option.bind a fun a => Option.map (f a) b := fun a b => by
cases a <;> cases b <;> rfl
simp [Primrec₂, Primrec, this] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_iff | null |
nat_iff' {f : α → β → σ} :
Primrec₂ f ↔
Primrec₂ fun m n : ℕ => (@decode α _ m).bind fun a => Option.map (f a) (@decode β _ n) :=
nat_iff.trans <| unpaired'.trans encode_iff | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_iff' | null |
to₂ {f : α × β → σ} (hf : Primrec f) : Primrec₂ fun a b => f (a, b) :=
hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | to₂ | null |
_root_.PrimrecPred.primrecRel {p : α × β → Prop} (hp : PrimrecPred p) :
PrimrecRel fun a b => p (a, b) :=
hp | lemma | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | _root_.PrimrecPred.primrecRel | null |
nat_rec {f : α → β} {g : α → ℕ × β → β} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec₂ fun a (n : ℕ) => n.rec (motive := fun _ => β) (f a) fun n IH => g a (n, IH) :=
Primrec₂.nat_iff.2 <|
((Nat.Primrec.casesOn' .zero <|
(Nat.Primrec.prec hf <|
.comp hg <|
Nat.Primrec.left.pair <|
(Nat.Primrec.left.comp .right).pair <|
Nat.Primrec.pred.comp <| Nat.Primrec.right.comp .right).comp <|
Nat.Primrec.right.pair <| Nat.Primrec.right.comp Nat.Primrec.left).comp <|
Nat.Primrec.id.pair <| (Primcodable.prim α).comp Nat.Primrec.left).of_eq
fun n => by
simp only [Nat.unpaired, id_eq, Nat.unpair_pair, decode_prod_val, decode_nat,
Option.bind_some, Option.map_map, Option.map_some]
rcases @decode α _ n.unpair.1 with - | a; · rfl
simp only [Nat.pred_eq_sub_one, encode_some, Nat.succ_eq_add_one, encodek, Option.map_some,
Option.bind_some, Option.map_map]
induction n.unpair.2 <;> simp [*, encodek] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_rec | null |
nat_rec' {f : α → ℕ} {g : α → β} {h : α → ℕ × β → β}
(hf : Primrec f) (hg : Primrec g) (hh : Primrec₂ h) :
Primrec fun a => (f a).rec (motive := fun _ => β) (g a) fun n IH => h a (n, IH) :=
(nat_rec hg hh).comp .id hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_rec' | null |
nat_rec₁ {f : ℕ → α → α} (a : α) (hf : Primrec₂ f) : Primrec (Nat.rec a f) :=
nat_rec' .id (const a) <| comp₂ hf Primrec₂.right | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_rec₁ | null |
nat_casesOn' {f : α → β} {g : α → ℕ → β} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec₂ fun a (n : ℕ) => (n.casesOn (f a) (g a) : β) :=
nat_rec hf <| hg.comp₂ Primrec₂.left <| comp₂ fst Primrec₂.right | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_casesOn' | null |
nat_casesOn {f : α → ℕ} {g : α → β} {h : α → ℕ → β} (hf : Primrec f) (hg : Primrec g)
(hh : Primrec₂ h) : Primrec fun a => ((f a).casesOn (g a) (h a) : β) :=
(nat_casesOn' hg hh).comp .id hf | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_casesOn | null |
nat_casesOn₁ {f : ℕ → α} (a : α) (hf : Primrec f) :
Primrec (fun (n : ℕ) => (n.casesOn a f : α)) :=
nat_casesOn .id (const a) (comp₂ hf .right) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_casesOn₁ | null |
nat_iterate {f : α → ℕ} {g : α → β} {h : α → β → β} (hf : Primrec f) (hg : Primrec g)
(hh : Primrec₂ h) : Primrec fun a => (h a)^[f a] (g a) :=
(nat_rec' hf hg (hh.comp₂ Primrec₂.left <| snd.comp₂ Primrec₂.right)).of_eq fun a => by
induction f a <;> simp [*, -Function.iterate_succ, Function.iterate_succ'] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_iterate | null |
option_casesOn {o : α → Option β} {f : α → σ} {g : α → β → σ} (ho : Primrec o)
(hf : Primrec f) (hg : Primrec₂ g) :
@Primrec _ σ _ _ fun a => Option.casesOn (o a) (f a) (g a) :=
encode_iff.1 <|
(nat_casesOn (encode_iff.2 ho) (encode_iff.2 hf) <|
pred.comp₂ <|
Primrec₂.encode_iff.2 <|
(Primrec₂.nat_iff'.1 hg).comp₂ ((@Primrec.encode α _).comp fst).to₂
Primrec₂.right).of_eq
fun a => by rcases o a with - | b <;> simp [encodek] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_casesOn | null |
option_bind {f : α → Option β} {g : α → β → Option σ} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec fun a => (f a).bind (g a) :=
(option_casesOn hf (const none) hg).of_eq fun a => by cases f a <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_bind | null |
option_bind₁ {f : α → Option σ} (hf : Primrec f) : Primrec fun o => Option.bind o f :=
option_bind .id (hf.comp snd).to₂ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_bind₁ | null |
option_map {f : α → Option β} {g : α → β → σ} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec fun a => (f a).map (g a) :=
(option_bind hf (option_some.comp₂ hg)).of_eq fun x => by cases f x <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_map | null |
option_map₁ {f : α → σ} (hf : Primrec f) : Primrec (Option.map f) :=
option_map .id (hf.comp snd).to₂ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_map₁ | null |
option_iget [Inhabited α] : Primrec (@Option.iget α _) :=
(option_casesOn .id (const <| @default α _) .right).of_eq fun o => by cases o <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_iget | null |
option_isSome : Primrec (@Option.isSome α) :=
(option_casesOn .id (const false) (const true).to₂).of_eq fun o => by cases o <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_isSome | null |
option_getD : Primrec₂ (@Option.getD α) :=
Primrec.of_eq (option_casesOn Primrec₂.left Primrec₂.right .right) fun ⟨o, a⟩ => by
cases o <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_getD | null |
bind_decode_iff {f : α → β → Option σ} :
(Primrec₂ fun a n => (@decode β _ n).bind (f a)) ↔ Primrec₂ f :=
⟨fun h => by simpa [encodek] using h.comp fst ((@Primrec.encode β _).comp snd), fun h =>
option_bind (Primrec.decode.comp snd) <| h.comp (fst.comp fst) snd⟩ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | bind_decode_iff | null |
map_decode_iff {f : α → β → σ} :
(Primrec₂ fun a n => (@decode β _ n).map (f a)) ↔ Primrec₂ f := by
simp only [Option.map_eq_bind]
exact bind_decode_iff.trans Primrec₂.option_some_iff | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | map_decode_iff | null |
nat_add : Primrec₂ ((· + ·) : ℕ → ℕ → ℕ) :=
Primrec₂.unpaired'.1 Nat.Primrec.add | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_add | null |
nat_sub : Primrec₂ ((· - ·) : ℕ → ℕ → ℕ) :=
Primrec₂.unpaired'.1 Nat.Primrec.sub | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_sub | null |
nat_mul : Primrec₂ ((· * ·) : ℕ → ℕ → ℕ) :=
Primrec₂.unpaired'.1 Nat.Primrec.mul | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_mul | null |
cond {c : α → Bool} {f : α → σ} {g : α → σ} (hc : Primrec c) (hf : Primrec f)
(hg : Primrec g) : Primrec fun a => bif (c a) then (f a) else (g a) :=
(nat_casesOn (encode_iff.2 hc) hg (hf.comp fst).to₂).of_eq fun a => by cases c a <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | cond | null |
ite {c : α → Prop} [DecidablePred c] {f : α → σ} {g : α → σ} (hc : PrimrecPred c)
(hf : Primrec f) (hg : Primrec g) : Primrec fun a => if c a then f a else g a := by
simpa [Bool.cond_decide] using cond hc.decide hf hg | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | ite | null |
nat_le : PrimrecRel ((· ≤ ·) : ℕ → ℕ → Prop) :=
Primrec₂.primrecRel ((nat_casesOn nat_sub (const true) (const false).to₂).of_eq fun p => by
dsimp [swap]
rcases e : p.1 - p.2 with - | n
· simp [Nat.sub_eq_zero_iff_le.1 e]
· simp [not_le.2 (Nat.lt_of_sub_eq_succ e)]) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_le | null |
nat_min : Primrec₂ (@min ℕ _) :=
ite nat_le fst snd | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_min | null |
nat_max : Primrec₂ (@max ℕ _) :=
ite (nat_le.comp fst snd) snd fst | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_max | null |
dom_bool (f : Bool → α) : Primrec f :=
(cond .id (const (f true)) (const (f false))).of_eq fun b => by cases b <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | dom_bool | null |
dom_bool₂ (f : Bool → Bool → α) : Primrec₂ f :=
(cond fst ((dom_bool (f true)).comp snd) ((dom_bool (f false)).comp snd)).of_eq fun ⟨a, b⟩ => by
cases a <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | dom_bool₂ | null |
protected not : Primrec not :=
dom_bool _ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | not | null |
protected and : Primrec₂ and :=
dom_bool₂ _ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | and | null |
protected or : Primrec₂ or :=
dom_bool₂ _ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | or | null |
protected _root_.PrimrecPred.not {p : α → Prop} :
(hp : PrimrecPred p) → PrimrecPred fun a => ¬p a
| ⟨_, hp⟩ => Primrec.primrecPred <| Primrec.not.comp hp |>.of_eq <| by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | _root_.PrimrecPred.not | null |
protected _root_.PrimrecPred.and {p q : α → Prop} :
(hp : PrimrecPred p) → (hq : PrimrecPred q) → PrimrecPred fun a => p a ∧ q a
| ⟨_, hp⟩, ⟨_, hq⟩ => Primrec.primrecPred <| Primrec.and.comp hp hq |>.of_eq <| by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | _root_.PrimrecPred.and | null |
protected _root_.PrimrecPred.or {p q : α → Prop} :
(hp : PrimrecPred p) → (hq : PrimrecPred q) → PrimrecPred fun a => p a ∨ q a
| ⟨_, hp⟩, ⟨_, hq⟩ => Primrec.primrecPred <| Primrec.or.comp hp hq |>.of_eq <| by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | _root_.PrimrecPred.or | null |
protected eq : PrimrecRel (@Eq α) :=
have : PrimrecRel fun a b : ℕ => a = b :=
(PrimrecPred.and nat_le nat_le.swap).of_eq fun a => by simp [le_antisymm_iff]
(this.decide.comp₂ (Primrec.encode.comp₂ Primrec₂.left)
(Primrec.encode.comp₂ Primrec₂.right)).primrecRel.of_eq
fun _ _ => encode_injective.eq_iff | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | eq | null |
protected beq [DecidableEq α] : Primrec₂ (@BEq.beq α _) := Primrec.eq.decide | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | beq | null |
nat_lt : PrimrecRel ((· < ·) : ℕ → ℕ → Prop) :=
(nat_le.comp snd fst).not.of_eq fun p => by simp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_lt | null |
option_guard {p : α → β → Prop} [DecidableRel p] (hp : PrimrecRel p) {f : α → β}
(hf : Primrec f) : Primrec fun a => Option.guard (p a) (f a) :=
ite (by simpa using hp.comp Primrec.id hf) (option_some_iff.2 hf) (const none) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_guard | null |
option_orElse : Primrec₂ ((· <|> ·) : Option α → Option α → Option α) :=
(option_casesOn fst snd (fst.comp fst).to₂).of_eq fun ⟨o₁, o₂⟩ => by cases o₁ <;> cases o₂ <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | option_orElse | null |
protected decode₂ : Primrec (decode₂ α) :=
option_bind .decode <|
option_guard (Primrec.eq.comp₂ (by exact encode_iff.mpr snd) (by exact fst.comp fst)) snd | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | decode₂ | null |
list_findIdx₁ {p : α → β → Bool} (hp : Primrec₂ p) :
∀ l : List β, Primrec fun a => l.findIdx (p a)
| [] => const 0
| a :: l => (cond (hp.comp .id (const a)) (const 0) (succ.comp (list_findIdx₁ hp l))).of_eq fun n =>
by 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 α] (l : List α) : Primrec fun a => l.idxOf a :=
list_findIdx₁ (.swap .beq) l | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_idxOf₁ | null |
dom_finite [Finite α] (f : α → σ) : Primrec f :=
let ⟨l, _, m⟩ := Finite.exists_univ_list α
option_some_iff.1 <| by
haveI := decidableEqOfEncodable α
refine ((list_getElem?₁ (l.map f)).comp (list_idxOf₁ l)).of_eq fun a => ?_
rw [List.getElem?_map, List.getElem?_idxOf (m a), Option.map_some]
@[deprecated (since := "2025-08-23")] alias dom_fintype := dom_finite | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | dom_finite | null |
PrimrecBounded (f : α → β) : Prop :=
∃ g : α → ℕ, Primrec g ∧ ∀ x, encode (f x) ≤ g x | def | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | PrimrecBounded | A function is `PrimrecBounded` if its size is bounded by a primitive recursive function |
nat_findGreatest {f : α → ℕ} {p : α → ℕ → Prop} [DecidableRel p]
(hf : Primrec f) (hp : PrimrecRel p) : Primrec fun x => (f x).findGreatest (p x) :=
(nat_rec' (h := fun x nih => if p x (nih.1 + 1) then nih.1 + 1 else nih.2)
hf (const 0) (ite (hp.comp fst (snd |> fst.comp |> succ.comp))
(snd |> fst.comp |> succ.comp) (snd.comp snd))).of_eq fun x => by
induction f x <;> simp [Nat.findGreatest, *] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_findGreatest | null |
of_graph {f : α → ℕ} (h₁ : PrimrecBounded f)
(h₂ : PrimrecRel fun a b => f a = b) : Primrec f := by
rcases h₁ with ⟨g, pg, hg : ∀ x, f x ≤ g x⟩
refine (nat_findGreatest pg h₂).of_eq fun n => ?_
exact (Nat.findGreatest_spec (P := fun b => f n = b) (hg n) rfl).symm | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | of_graph | To show a function `f : α → ℕ` is primitive recursive, it is enough to show that the function
is bounded by a primitive recursive function and that its graph is primitive recursive |
nat_div : Primrec₂ ((· / ·) : ℕ → ℕ → ℕ) := by
refine of_graph ⟨_, fst, fun p => Nat.div_le_self _ _⟩ ?_
have : PrimrecRel fun (a : ℕ × ℕ) (b : ℕ) => (a.2 = 0 ∧ b = 0) ∨
(0 < a.2 ∧ b * a.2 ≤ a.1 ∧ a.1 < (b + 1) * a.2) :=
PrimrecPred.or
(.and (const 0 |> Primrec.eq.comp (fst |> snd.comp)) (const 0 |> Primrec.eq.comp snd))
(.and (nat_lt.comp (const 0) (fst |> snd.comp)) <|
.and (nat_le.comp (nat_mul.comp snd (fst |> snd.comp)) (fst |> fst.comp))
(nat_lt.comp (fst.comp fst) (nat_mul.comp (Primrec.succ.comp snd) (snd.comp fst))))
refine this.of_eq ?_
rintro ⟨a, k⟩ q
if H : k = 0 then simp [H, eq_comm]
else
have : q * k ≤ a ∧ a < (q + 1) * k ↔ q = a / k := by
rw [le_antisymm_iff, ← (@Nat.lt_succ _ q), Nat.le_div_iff_mul_le (Nat.pos_of_ne_zero H),
Nat.div_lt_iff_lt_mul (Nat.pos_of_ne_zero H)]
simpa [H, zero_lt_iff, eq_comm (b := q)] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_div | null |
nat_mod : Primrec₂ ((· % ·) : ℕ → ℕ → ℕ) :=
(nat_sub.comp fst (nat_mul.comp snd nat_div)).to₂.of_eq fun m n => by
apply Nat.sub_eq_of_eq_add
simp [add_comm (m % n), Nat.div_add_mod] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_mod | null |
nat_bodd : Primrec Nat.bodd :=
(Primrec.beq.comp (nat_mod.comp .id (const 2)) (const 1)).of_eq fun n => by
cases H : n.bodd <;> simp [Nat.mod_two_of_bodd, H] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_bodd | null |
nat_div2 : Primrec Nat.div2 :=
(nat_div.comp .id (const 2)).of_eq fun n => n.div2_val.symm | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_div2 | null |
nat_double : Primrec (fun n : ℕ => 2 * n) :=
nat_mul.comp (const _) Primrec.id | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_double | null |
nat_double_succ : Primrec (fun n : ℕ => 2 * n + 1) :=
nat_double |> Primrec.succ.comp | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | nat_double_succ | null |
private prim : Primcodable (List β) := ⟨H⟩ | def | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | prim | null |
private list_casesOn' {f : α → List β} {g : α → σ} {h : α → β × List β → σ}
(hf : haveI := prim H; Primrec f) (hg : Primrec g) (hh : haveI := prim H; Primrec₂ h) :
@Primrec _ σ _ _ fun a => List.casesOn (f a) (g a) fun b l => h a (b, l) :=
letI := prim H
have :
@Primrec _ (Option σ) _ _ fun a =>
(@decode (Option (β × List β)) _ (encode (f a))).map fun o => Option.casesOn o (g a) (h a) :=
((@map_decode_iff _ (Option (β × List β)) _ _ _ _ _).2 <|
to₂ <|
option_casesOn snd (hg.comp fst) (hh.comp₂ (fst.comp₂ Primrec₂.left) Primrec₂.right)).comp
.id (encode_iff.2 hf)
option_some_iff.1 <| this.of_eq fun a => by rcases f a with - | ⟨b, l⟩ <;> simp [encodek] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_casesOn' | null |
private list_foldl' {f : α → List β} {g : α → σ} {h : α → σ × β → σ}
(hf : haveI := prim H; Primrec f) (hg : Primrec g) (hh : haveI := prim H; Primrec₂ h) :
Primrec fun a => (f a).foldl (fun s b => h a (s, b)) (g a) := by
letI := prim H
let G (a : α) (IH : σ × List β) : σ × List β := List.casesOn IH.2 IH fun b l => (h a (IH.1, b), l)
have hG : Primrec₂ G := list_casesOn' H (snd.comp snd) snd <|
to₂ <|
pair (hh.comp (fst.comp fst) <| pair ((fst.comp snd).comp fst) (fst.comp snd))
(snd.comp snd)
let F := fun (a : α) (n : ℕ) => (G a)^[n] (g a, f a)
have hF : Primrec fun a => (F a (encode (f a))).1 :=
(fst.comp <|
nat_iterate (encode_iff.2 hf) (pair hg hf) <|
hG)
suffices ∀ a n, F a n = (((f a).take n).foldl (fun s b => h a (s, b)) (g a), (f a).drop n) by
refine hF.of_eq fun a => ?_
rw [this, List.take_of_length_le (length_le_encode _)]
introv
dsimp only [F]
generalize f a = l
generalize g a = x
induction n generalizing l x with
| zero => rfl
| succ n IH =>
simp only [iterate_succ, comp_apply]
rcases l with - | ⟨b, l⟩ <;> simp [G, IH] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_foldl' | null |
private list_cons' : (haveI := prim H; Primrec₂ (@List.cons β)) :=
letI := prim H
encode_iff.1 (succ.comp <| Primrec₂.natPair.comp (encode_iff.2 fst) (encode_iff.2 snd)) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_cons' | null |
private list_reverse' :
haveI := prim H
Primrec (@List.reverse β) :=
letI := prim H
(list_foldl' H .id (const []) <| to₂ <| ((list_cons' H).comp snd fst).comp snd).of_eq
(suffices ∀ l r, List.foldl (fun (s : List β) (b : β) => b :: s) r l = List.reverseAux l r from
fun l => this l []
fun l => by induction l <;> simp [*, List.reverseAux]) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_reverse' | null |
sum : Primcodable (α ⊕ β) :=
⟨Primrec.nat_iff.1 <|
(encode_iff.2
(cond nat_bodd
(((@Primrec.decode β _).comp nat_div2).option_map <|
to₂ <| nat_double_succ.comp (Primrec.encode.comp snd))
(((@Primrec.decode α _).comp nat_div2).option_map <|
to₂ <| nat_double.comp (Primrec.encode.comp snd)))).of_eq
fun n =>
show _ = encode (decodeSum n) by
simp only [decodeSum, Nat.boddDiv2_eq]
cases Nat.bodd n <;> simp
· cases @decode α _ n.div2 <;> rfl
· cases @decode β _ n.div2 <;> rfl⟩ | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sum | null |
list : Primcodable (List α) :=
⟨letI H := Primcodable.prim (List ℕ)
have : Primrec₂ fun (a : α) (o : Option (List ℕ)) => o.map (List.cons (encode a)) :=
option_map snd <| (list_cons' H).comp ((@Primrec.encode α _).comp (fst.comp fst)) snd
have :
Primrec fun n =>
(ofNat (List ℕ) n).reverse.foldl
(fun o m => (@decode α _ m).bind fun a => o.map (List.cons (encode a))) (some []) :=
list_foldl' H ((list_reverse' H).comp (.ofNat (List ℕ))) (const (some []))
(Primrec.comp₂ (bind_decode_iff.2 <| .swap this) Primrec₂.right)
nat_iff.1 <|
(encode_iff.2 this).of_eq fun n => by
rw [List.foldl_reverse]
apply Nat.case_strong_induction_on n; · simp
intro n IH; simp
rcases @decode α _ n.unpair.1 with - | a; · rfl
simp only [Option.bind_some, Option.map_some]
suffices ∀ (o : Option (List ℕ)) (p), encode o = encode p →
encode (Option.map (List.cons (encode a)) o) = encode (Option.map (List.cons a) p) from
this _ _ (IH _ (Nat.unpair_right_le n))
intro o p IH
cases o <;> cases p
· rfl
· injection IH
· injection IH
· exact congr_arg (fun k => (Nat.pair (encode a) k).succ.succ) (Nat.succ.inj IH)⟩ | instance | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list | null |
sumInl : Primrec (@Sum.inl α β) :=
encode_iff.1 <| nat_double.comp Primrec.encode | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sumInl | null |
sumInr : Primrec (@Sum.inr α β) :=
encode_iff.1 <| nat_double_succ.comp Primrec.encode | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sumInr | null |
sumCasesOn {f : α → β ⊕ γ} {g : α → β → σ} {h : α → γ → σ} (hf : Primrec f)
(hg : Primrec₂ g) (hh : Primrec₂ h) : @Primrec _ σ _ _ fun a => Sum.casesOn (f a) (g a) (h a) :=
option_some_iff.1 <|
(cond (nat_bodd.comp <| encode_iff.2 hf)
(option_map (Primrec.decode.comp <| nat_div2.comp <| encode_iff.2 hf) hh)
(option_map (Primrec.decode.comp <| nat_div2.comp <| encode_iff.2 hf) hg)).of_eq
fun a => by rcases f a with b | c <;> simp [Nat.div2_val, encodek] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | sumCasesOn | null |
list_cons : Primrec₂ (@List.cons α) :=
list_cons' (Primcodable.prim _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_cons | null |
list_casesOn {f : α → List β} {g : α → σ} {h : α → β × List β → σ} :
Primrec f →
Primrec g →
Primrec₂ h → @Primrec _ σ _ _ fun a => List.casesOn (f a) (g a) fun b l => h a (b, l) :=
list_casesOn' (Primcodable.prim _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_casesOn | null |
list_foldl {f : α → List β} {g : α → σ} {h : α → σ × β → σ} :
Primrec f →
Primrec g → Primrec₂ h → Primrec fun a => (f a).foldl (fun s b => h a (s, b)) (g a) :=
list_foldl' (Primcodable.prim _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_foldl | null |
list_reverse : Primrec (@List.reverse α) :=
list_reverse' (Primcodable.prim _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_reverse | null |
list_foldr {f : α → List β} {g : α → σ} {h : α → β × σ → σ} (hf : Primrec f)
(hg : Primrec g) (hh : Primrec₂ h) :
Primrec fun a => (f a).foldr (fun b s => h a (b, s)) (g a) :=
(list_foldl (list_reverse.comp hf) hg <| to₂ <| hh.comp fst <| (pair snd fst).comp snd).of_eq
fun a => by simp [List.foldl_reverse] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_foldr | null |
list_head? : Primrec (@List.head? α) :=
(list_casesOn .id (const none) (option_some_iff.2 <| fst.comp snd).to₂).of_eq fun l => by
cases l <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_head | null |
list_headI [Inhabited α] : Primrec (@List.headI α _) :=
(option_iget.comp list_head?).of_eq fun l => l.head!_eq_head?.symm | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_headI | null |
list_tail : Primrec (@List.tail α) :=
(list_casesOn .id (const []) (snd.comp snd).to₂).of_eq fun l => by cases l <;> rfl | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_tail | null |
list_rec {f : α → List β} {g : α → σ} {h : α → β × List β × σ → σ} (hf : Primrec f)
(hg : Primrec g) (hh : Primrec₂ h) :
@Primrec _ σ _ _ fun a => List.recOn (f a) (g a) fun b l IH => h a (b, l, IH) :=
let F (a : α) := (f a).foldr (fun (b : β) (s : List β × σ) => (b :: s.1, h a (b, s))) ([], g a)
have : Primrec F :=
list_foldr hf (pair (const []) hg) <|
to₂ <| pair ((list_cons.comp fst (fst.comp snd)).comp snd) hh
(snd.comp this).of_eq fun a => by
suffices F a = (f a, List.recOn (f a) (g a) fun b l IH => h a (b, l, IH)) by rw [this]
dsimp [F]
induction f a <;> simp [*] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_rec | null |
list_getElem? : Primrec₂ ((·[·]? : List α → ℕ → Option α)) :=
let F (l : List α) (n : ℕ) :=
l.foldl
(fun (s : ℕ ⊕ α) (a : α) =>
Sum.casesOn s (@Nat.casesOn (fun _ => ℕ ⊕ α) · (Sum.inr a) Sum.inl) Sum.inr)
(Sum.inl n)
have hF : Primrec₂ F :=
(list_foldl fst (sumInl.comp snd)
((sumCasesOn fst (nat_casesOn snd (sumInr.comp <| snd.comp fst) (sumInl.comp snd).to₂).to₂
(sumInr.comp snd).to₂).comp
snd).to₂).to₂
have :
@Primrec _ (Option α) _ _ fun p : List α × ℕ => Sum.casesOn (F p.1 p.2) (fun _ => none) some :=
sumCasesOn hF (const none).to₂ (option_some.comp snd).to₂
this.to₂.of_eq fun l n => by
dsimp; symm
induction l generalizing n with
| nil => rfl
| cons a l IH =>
rcases n with - | n
· dsimp [F]
clear IH
induction l <;> simp_all
· simpa using IH ..
@[deprecated (since := "2025-02-14")] alias list_get? := list_getElem? | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_getElem | null |
list_getD (d : α) : Primrec₂ fun l n => List.getD l n d := by
simp only [List.getD_eq_getElem?_getD]
exact option_getD.comp₂ list_getElem? (const _) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_getD | null |
list_getI [Inhabited α] : Primrec₂ (@List.getI α _) :=
list_getD _ | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_getI | null |
list_append : Primrec₂ ((· ++ ·) : List α → List α → List α) :=
(list_foldr fst snd <| to₂ <| comp (@list_cons α _) snd).to₂.of_eq fun l₁ l₂ => by
induction l₁ <;> simp [*] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_append | null |
list_concat : Primrec₂ fun l (a : α) => l ++ [a] :=
list_append.comp fst (list_cons.comp snd (const [])) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_concat | null |
list_map {f : α → List β} {g : α → β → σ} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec fun a => (f a).map (g a) :=
(list_foldr hf (const []) <|
to₂ <| list_cons.comp (hg.comp fst (fst.comp snd)) (snd.comp snd)).of_eq
fun a => by induction f a <;> simp [*] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_map | null |
list_range : Primrec List.range :=
(nat_rec' .id (const []) ((list_concat.comp snd fst).comp snd).to₂).of_eq fun n => by
simp; induction n <;> simp [*, List.range_succ] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_range | null |
list_flatten : Primrec (@List.flatten α) :=
(list_foldr .id (const []) <| to₂ <| comp (@list_append α _) snd).of_eq fun l => by
dsimp; induction l <;> simp [*] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_flatten | null |
list_flatMap {f : α → List β} {g : α → β → List σ} (hf : Primrec f) (hg : Primrec₂ g) :
Primrec (fun a => (f a).flatMap (g a)) := list_flatten.comp (list_map hf hg) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_flatMap | null |
optionToList : Primrec (Option.toList : Option α → List α) :=
(option_casesOn Primrec.id (const [])
((list_cons.comp Primrec.id (const [])).comp₂ Primrec₂.right)).of_eq
(fun o => by rcases o <;> simp) | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | optionToList | null |
listFilterMap {f : α → List β} {g : α → β → Option σ}
(hf : Primrec f) (hg : Primrec₂ g) : Primrec fun a => (f a).filterMap (g a) :=
(list_flatMap hf (comp₂ optionToList hg)).of_eq
fun _ ↦ Eq.symm <| List.filterMap_eq_flatMap_toList _ _
variable {p : α → Prop} [DecidablePred p] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | listFilterMap | null |
list_length : Primrec (@List.length α) :=
(list_foldr (@Primrec.id (List α) _) (const 0) <| to₂ <| (succ.comp <| snd.comp snd).to₂).of_eq
fun l => by dsimp; induction l <;> simp [*] | theorem | Computability | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Logic.Encodable.Pi",
"Mathlib.Logic.Function.Iterate"
] | Mathlib/Computability/Primrec.lean | list_length | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.