ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.Kernel.measurable_kernel_prod_mk_left'
theorem measurable_kernel_prod_mk_left' [IsSFiniteKernel η] {s : Set (β × γ)} (hs : MeasurableSet s)
    (a : α) : Measurable fun b => η (a, b) (Prod.mk b ⁻¹' s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {s : Set (β × γ)} (hs : MeasurableSet s) (a : α)
Goal: Measurable fun b => (η (a, b)) (Prod.mk b ⁻¹' s)
-- ProbabilityTheory.Kernel.measurable_kernel_prod_mk_right
theorem measurable_kernel_prod_mk_right [IsSFiniteKernel κ] {s : Set (β × α)}
    (hs : MeasurableSet s) : Measurable fun y => κ y ((fun x => (x, y)) ⁻¹' s) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {s : Set (β × α)} (hs : MeasurableSet s)
Goal: Measurable fun y => (κ y) ((fun x => (x, y)) ⁻¹' s)
-- ProbabilityTheory.Kernel.measurable_lintegral_indicator_const
theorem Kernel.measurable_lintegral_indicator_const {t : Set (α × β)} (ht : MeasurableSet t)
    (c : ℝ≥0∞) : Measurable fun a => ∫⁻ b, t.indicator (Function.const (α × β) c) (a, b) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {t : Set (α × β)} (ht : MeasurableSet t) (c : ℝ≥0∞)
Goal: Measurable fun a => ∫⁻ (b : β), t.indicator (Function.const (α × β) c) (a, b) ∂κ a
-- Measurable.lintegral_kernel_prod_right
theorem _root_.Measurable.lintegral_kernel_prod_right {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun a => ∫⁻ b, f a b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : α → β → ℝ≥0∞} (hf : Measurable (Function.uncurry f))
Goal: Measurable fun a => ∫⁻ (b : β), f a b ∂κ a
-- Measurable.lintegral_kernel_prod_right'
theorem _root_.Measurable.lintegral_kernel_prod_right' {f : α × β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun a => ∫⁻ b, f (a, b) ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : α × β → ℝ≥0∞} (hf : Measurable f)
Goal: Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a
-- Measurable.lintegral_kernel_prod_right''
theorem _root_.Measurable.lintegral_kernel_prod_right'' {f : β × γ → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun x => ∫⁻ y, f (x, y) ∂η (a, x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {η : ProbabilityTheory.Kernel (α × β) γ} {a : α} [ProbabilityTheory.IsSFiniteKernel η] {f : β × γ → ℝ≥0∞} (hf : Measurable f)
Goal: Measurable fun x => ∫⁻ (y : γ), f (x, y) ∂η (a, x)
-- Measurable.setLIntegral_kernel_prod_right
theorem _root_.Measurable.setLIntegral_kernel_prod_right {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) {s : Set β} (hs : MeasurableSet s) :
    Measurable fun a => ∫⁻ b in s, f a b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : α → β → ℝ≥0∞} (hf : Measurable (Function.uncurry f)) {s : Set β} (hs : MeasurableSet s)
Goal: Measurable fun a => ∫⁻ (b : β) in s, f a b ∂κ a
-- Measurable.lintegral_kernel_prod_left'
theorem _root_.Measurable.lintegral_kernel_prod_left' {f : β × α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun y => ∫⁻ x, f (x, y) ∂κ y 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : β × α → ℝ≥0∞} (hf : Measurable f)
Goal: Measurable fun y => ∫⁻ (x : β), f (x, y) ∂κ y
-- Measurable.lintegral_kernel_prod_left
theorem _root_.Measurable.lintegral_kernel_prod_left {f : β → α → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun y => ∫⁻ x, f x y ∂κ y 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : β → α → ℝ≥0∞} (hf : Measurable (Function.uncurry f))
Goal: Measurable fun y => ∫⁻ (x : β), f x y ∂κ y
-- Measurable.setLIntegral_kernel_prod_left
theorem _root_.Measurable.setLIntegral_kernel_prod_left {f : β → α → ℝ≥0∞}
    (hf : Measurable (uncurry f)) {s : Set β} (hs : MeasurableSet s) :
    Measurable fun b => ∫⁻ a in s, f a b ∂κ b 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : β → α → ℝ≥0∞} (hf : Measurable (Function.uncurry f)) {s : Set β} (hs : MeasurableSet s)
Goal: Measurable fun b => ∫⁻ (a : β) in s, f a b ∂κ b
-- Measurable.lintegral_kernel
theorem _root_.Measurable.lintegral_kernel {f : β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun a => ∫⁻ b, f b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : β → ℝ≥0∞} (hf : Measurable f)
Goal: Measurable fun a => ∫⁻ (b : β), f b ∂κ a
-- Measurable.setLIntegral_kernel
theorem _root_.Measurable.setLIntegral_kernel {f : β → ℝ≥0∞} (hf : Measurable f) {s : Set β}
    (hs : MeasurableSet s) : Measurable fun a => ∫⁻ b in s, f b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ] {f : β → ℝ≥0∞} (hf : Measurable f) {s : Set β} (hs : MeasurableSet s)
Goal: Measurable fun a => ∫⁻ (b : β) in s, f b ∂κ a
-- ProbabilityTheory.measurableSet_kernel_integrable
theorem measurableSet_kernel_integrable ⦃f : α → β → E⦄ (hf : StronglyMeasurable (uncurry f)) :
    MeasurableSet {x | Integrable (f x) (κ x)} 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {E : Type u_4} [NormedAddCommGroup E] [ProbabilityTheory.IsSFiniteKernel κ] ⦃f : α → β → E⦄ (hf : MeasureTheory.StronglyMeasurable (Function.uncurry f))
Goal: MeasurableSet {x | MeasureTheory.Integrable (f x) (κ x)}
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_right
theorem StronglyMeasurable.integral_kernel_prod_right ⦃f : α → β → E⦄
    (hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun x => ∫ y, f x y ∂κ x 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel κ] ⦃f : α → β → E⦄ (hf : MeasureTheory.StronglyMeasurable (Function.uncurry f))
Goal: MeasureTheory.StronglyMeasurable fun x => ∫ (y : β), f x y ∂κ x
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_right'
theorem StronglyMeasurable.integral_kernel_prod_right' ⦃f : α × β → E⦄ (hf : StronglyMeasurable f) :
    StronglyMeasurable fun x => ∫ y, f (x, y) ∂κ x 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel κ] ⦃f : α × β → E⦄ (hf : MeasureTheory.StronglyMeasurable f)
Goal: MeasureTheory.StronglyMeasurable fun x => ∫ (y : β), f (x, y) ∂κ x
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_right''
theorem StronglyMeasurable.integral_kernel_prod_right'' {f : β × γ → E}
    (hf : StronglyMeasurable f) : StronglyMeasurable fun x => ∫ y, f (x, y) ∂η (a, x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {η : ProbabilityTheory.Kernel (α × β) γ} {a : α} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel η] {f : β × γ → E} (hf : MeasureTheory.StronglyMeasurable f)
Goal: MeasureTheory.StronglyMeasurable fun x => ∫ (y : γ), f (x, y) ∂η (a, x)
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_left
theorem StronglyMeasurable.integral_kernel_prod_left ⦃f : β → α → E⦄
    (hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun y => ∫ x, f x y ∂κ y 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel κ] ⦃f : β → α → E⦄ (hf : MeasureTheory.StronglyMeasurable (Function.uncurry f))
Goal: MeasureTheory.StronglyMeasurable fun y => ∫ (x : β), f x y ∂κ y
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_left'
theorem StronglyMeasurable.integral_kernel_prod_left' ⦃f : β × α → E⦄ (hf : StronglyMeasurable f) :
    StronglyMeasurable fun y => ∫ x, f (x, y) ∂κ y 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel κ] ⦃f : β × α → E⦄ (hf : MeasureTheory.StronglyMeasurable f)
Goal: MeasureTheory.StronglyMeasurable fun y => ∫ (x : β), f (x, y) ∂κ y
-- MeasureTheory.StronglyMeasurable.integral_kernel_prod_left''
theorem StronglyMeasurable.integral_kernel_prod_left'' {f : γ × β → E} (hf : StronglyMeasurable f) :
    StronglyMeasurable fun y => ∫ x, f (x, y) ∂η (a, y) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {η : ProbabilityTheory.Kernel (α × β) γ} {a : α} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProbabilityTheory.IsSFiniteKernel η] {f : γ × β → E} (hf : MeasureTheory.StronglyMeasurable f)
Goal: MeasureTheory.StronglyMeasurable fun y => ∫ (x : γ), f (x, y) ∂η (a, y)
-- PMF.integral_eq_tsum
theorem integral_eq_tsum (p : PMF α) (f : α → E) (hf : Integrable f p.toMeasure) :
    ∫ a, f a ∂(p.toMeasure) = ∑' a, (p a).toReal • f a 
Arguments: {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (p : PMF α) (f : α → E) (hf : MeasureTheory.Integrable f p.toMeasure)
Goal: ∫ (a : α), f a ∂p.toMeasure = ∑' (a : α), (p a).toReal • f a
-- PMF.integral_eq_sum
theorem integral_eq_sum [Fintype α] (p : PMF α) (f : α → E) :
    ∫ a, f a ∂(p.toMeasure) = ∑ a, (p a).toReal • f a 
Arguments: {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] [Fintype α] (p : PMF α) (f : α → E)
Goal: ∫ (a : α), f a ∂p.toMeasure = ∑ a : α, (p a).toReal • f a
-- PMF.bernoulli_expectation
theorem bernoulli_expectation {p : ℝ≥0∞} (h : p ≤ 1) :
    ∫ b, cond b 1 0 ∂((bernoulli p h).toMeasure) = p.toReal 
Arguments: {p : ENNReal} (h : p ≤ 1)
Goal: ∫ (b : Bool), bif b then 1 else 0 ∂(PMF.bernoulli p h).toMeasure = p.toReal
-- Nat.Partrec.rfind'
theorem rfind' {f} (hf : Nat.Partrec f) :
    Nat.Partrec
      (Nat.unpaired fun a m =>
        (Nat.rfind fun n => (fun m => m = 0) <$> f (Nat.pair a (n + m))).map (· + m)) 
Arguments: {f : ℕ →. ℕ} (hf : Nat.Partrec f)
Goal: Nat.Partrec
  (Nat.unpaired fun a m =>
    Part.map (fun x => x + m) (Nat.rfind fun n => (fun m => decide (m = 0)) <$> f (Nat.pair a (n + m))))
-- Nat.Partrec.Code.const_inj
theorem const_inj : ∀ {n₁ n₂}, Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂
  
Arguments: {n₁ n₂ : ℕ}
Goal: Nat.Partrec.Code.const n₁ = Nat.Partrec.Code.const n₂ → n₁ = n₂
-- _private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.encode_ofNatCode
private theorem encode_ofNatCode : ∀ n, encodeCode (ofNatCode n) = n
  
Arguments: (n : ℕ)
Goal: (Nat.Partrec.Code.ofNatCode n).encodeCode = n
-- Nat.Partrec.Code.encodeCode_eq
theorem encodeCode_eq : encode = encodeCode 
Goal: Encodable.encode = Nat.Partrec.Code.encodeCode
-- Nat.Partrec.Code.ofNatCode_eq
theorem ofNatCode_eq : ofNat Code = ofNatCode 
Goal: Denumerable.ofNat Nat.Partrec.Code = Nat.Partrec.Code.ofNatCode
-- Nat.Partrec.Code.encode_lt_pair
theorem encode_lt_pair (cf cg) :
    encode cf < encode (pair cf cg) ∧ encode cg < encode (pair cf cg) 
Arguments: (cf cg : Nat.Partrec.Code)
Goal: Encodable.encode cf < Encodable.encode (cf.pair cg) ∧ Encodable.encode cg < Encodable.encode (cf.pair cg)
-- Nat.Partrec.Code.encode_lt_comp
theorem encode_lt_comp (cf cg) :
    encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg) 
Arguments: (cf cg : Nat.Partrec.Code)
Goal: Encodable.encode cf < Encodable.encode (cf.comp cg) ∧ Encodable.encode cg < Encodable.encode (cf.comp cg)
-- Nat.Partrec.Code.encode_lt_prec
theorem encode_lt_prec (cf cg) :
    encode cf < encode (prec cf cg) ∧ encode cg < encode (prec cf cg) 
Arguments: (cf cg : Nat.Partrec.Code)
Goal: Encodable.encode cf < Encodable.encode (cf.prec cg) ∧ Encodable.encode cg < Encodable.encode (cf.prec cg)
-- Nat.Partrec.Code.encode_lt_rfind'
theorem encode_lt_rfind' (cf) : encode cf < encode (rfind' cf) 
Arguments: (cf : Nat.Partrec.Code)
Goal: Encodable.encode cf < Encodable.encode cf.rfind'
-- Nat.Partrec.Code.pair_prim
theorem pair_prim : Primrec₂ pair 
Goal: Primrec₂ Nat.Partrec.Code.pair
-- Nat.Partrec.Code.comp_prim
theorem comp_prim : Primrec₂ comp 
Goal: Primrec₂ Nat.Partrec.Code.comp
-- Nat.Partrec.Code.prec_prim
theorem prec_prim : Primrec₂ prec 
Goal: Primrec₂ Nat.Partrec.Code.prec
-- Nat.Partrec.Code.rfind_prim
theorem rfind_prim : Primrec rfind' 
Goal: Primrec Nat.Partrec.Code.rfind'
-- Nat.Partrec.Code.rec_prim'
theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ}
    (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ}
    (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr)
    {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ}
    (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) :
    let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg)
    let CO (a) cf cg hf hg := co a (cf, cg, hf, hg)
    let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg)
    let RF (a) cf hf := rf a (cf, hf)
    let F (a : α) (c : Code) : σ :=
      Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a)
    Primrec (fun a => F a (c a) : α → σ) 
Arguments: {α : Type u_1} {σ : Type u_2} [Primcodable α] [Primcodable σ] {c : α → Nat.Partrec.Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hpr : Primrec₂ pr) {co : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hpc : Primrec₂ pc) {rf : α → Nat.Partrec.Code × σ → σ} (hrf : Primrec₂ rf)
Goal: let PR := fun a cf cg hf hg => pr a (cf, cg, hf, hg);
let CO := fun a cf cg hf hg => co a (cf, cg, hf, hg);
let PC := fun a cf cg hf hg => pc a (cf, cg, hf, hg);
let RF := fun a cf hf => rf a (cf, hf);
let F := fun a c => Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a);
Primrec fun a => F a (c a)
-- Nat.Partrec.Code.rec_prim
theorem rec_prim {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ}
    (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ}
    (hr : Primrec r) {pr : α → Code → Code → σ → σ → σ}
    (hpr : Primrec fun a : α × Code × Code × σ × σ => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2)
    {co : α → Code → Code → σ → σ → σ}
    (hco : Primrec fun a : α × Code × Code × σ × σ => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2)
    {pc : α → Code → Code → σ → σ → σ}
    (hpc : Primrec fun a : α × Code × Code × σ × σ => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2)
    {rf : α → Code → σ → σ} (hrf : Primrec fun a : α × Code × σ => rf a.1 a.2.1 a.2.2) :
    let F (a : α) (c : Code) : σ :=
      Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a)
    Primrec fun a => F a (c a) 
Arguments: {α : Type u_1} {σ : Type u_2} [Primcodable α] [Primcodable σ] {c : α → Nat.Partrec.Code} (hc : Primrec c) {z : α → σ} (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ} (hr : Primrec r) {pr : α → Nat.Partrec.Code → Nat.Partrec.Code → σ → σ → σ} (hpr : Primrec fun a => pr a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {co : α → Nat.Partrec.Code → Nat.Partrec.Code → σ → σ → σ} (hco : Primrec fun a => co a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {pc : α → Nat.Partrec.Code → Nat.Partrec.Code → σ → σ → σ} (hpc : Primrec fun a => pc a.1 a.2.1 a.2.2.1 a.2.2.2.1 a.2.2.2.2) {rf : α → Nat.Partrec.Code → σ → σ} (hrf : Primrec fun a => rf a.1 a.2.1 a.2.2)
Goal: let F := fun a c => Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (pr a) (co a) (pc a) (rf a);
Primrec fun a => F a (c a)
-- Nat.Partrec.Code.rec_computable
theorem rec_computable {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Computable c)
    {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l)
    {r : α → σ} (hr : Computable r) {pr : α → Code × Code × σ × σ → σ} (hpr : Computable₂ pr)
    {co : α → Code × Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Code × Code × σ × σ → σ}
    (hpc : Computable₂ pc) {rf : α → Code × σ → σ} (hrf : Computable₂ rf) :
    let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg)
    let CO (a) cf cg hf hg := co a (cf, cg, hf, hg)
    let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg)
    let RF (a) cf hf := rf a (cf, hf)
    let F (a : α) (c : Code) : σ :=
      Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a)
    Computable fun a => F a (c a) 
Arguments: {α : Type u_1} {σ : Type u_2} [Primcodable α] [Primcodable σ] {c : α → Nat.Partrec.Code} (hc : Computable c) {z : α → σ} (hz : Computable z) {s : α → σ} (hs : Computable s) {l : α → σ} (hl : Computable l) {r : α → σ} (hr : Computable r) {pr : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hpr : Computable₂ pr) {co : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hco : Computable₂ co) {pc : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ} (hpc : Computable₂ pc) {rf : α → Nat.Partrec.Code × σ → σ} (hrf : Computable₂ rf)
Goal: let PR := fun a cf cg hf hg => pr a (cf, cg, hf, hg);
let CO := fun a cf cg hf hg => co a (cf, cg, hf, hg);
let PC := fun a cf cg hf hg => pc a (cf, cg, hf, hg);
let RF := fun a cf hf => rf a (cf, hf);
let F := fun a c => Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a);
Computable fun a => F a (c a)
-- Nat.Partrec.Code.eval_prec_zero
@[simp]
theorem eval_prec_zero (cf cg : Code) (a : ℕ) : eval (prec cf cg) (Nat.pair a 0) = eval cf a 
Arguments: (cf cg : Nat.Partrec.Code) (a : ℕ)
Goal: (cf.prec cg).eval (Nat.pair a 0) = cf.eval a
-- Nat.Partrec.Code.eval_prec_succ
theorem eval_prec_succ (cf cg : Code) (a k : ℕ) :
    eval (prec cf cg) (Nat.pair a (Nat.succ k)) =
      do {let ih ← eval (prec cf cg) (Nat.pair a k); eval cg (Nat.pair a (Nat.pair k ih))} 
Arguments: (cf cg : Nat.Partrec.Code) (a k : ℕ)
Goal: (cf.prec cg).eval (Nat.pair a k.succ) = do
  let ih ← (cf.prec cg).eval (Nat.pair a k)
  cg.eval (Nat.pair a (Nat.pair k ih))
-- Nat.Partrec.Code.eval_const
@[simp]
theorem eval_const : ∀ n m, eval (Code.const n) m = Part.some n
  
Arguments: (n m : ℕ)
Goal: (Nat.Partrec.Code.const n).eval m = Part.some n
-- Nat.Partrec.Code.eval_id
@[simp]
theorem eval_id (n) : eval Code.id n = Part.some n 
Arguments: (n : ℕ)
Goal: Nat.Partrec.Code.id.eval n = Part.some n
-- Nat.Partrec.Code.eval_curry
@[simp]
theorem eval_curry (c n x) : eval (curry c n) x = eval c (Nat.pair n x) 
Arguments: (c : Nat.Partrec.Code) (n x : ℕ)
Goal: (c.curry n).eval x = c.eval (Nat.pair n x)
-- Nat.Partrec.Code.const_prim
theorem const_prim : Primrec Code.const 
Goal: Primrec Nat.Partrec.Code.const
-- Nat.Partrec.Code.curry_prim
theorem curry_prim : Primrec₂ curry 
Goal: Primrec₂ Nat.Partrec.Code.curry
-- Nat.Partrec.Code.curry_inj
theorem curry_inj {c₁ c₂ n₁ n₂} (h : curry c₁ n₁ = curry c₂ n₂) : c₁ = c₂ ∧ n₁ = n₂ 
Arguments: {c₁ c₂ : Nat.Partrec.Code} {n₁ n₂ : ℕ} (h : c₁.curry n₁ = c₂.curry n₂)
Goal: c₁ = c₂ ∧ n₁ = n₂
-- Nat.Partrec.Code.smn
theorem smn :
    ∃ f : Code → ℕ → Code, Computable₂ f ∧ ∀ c n x, eval (f c n) x = eval c (Nat.pair n x) 
Goal: ∃ f, Computable₂ f ∧ ∀ (c : Nat.Partrec.Code) (n x : ℕ), (f c n).eval x = c.eval (Nat.pair n x)
-- Nat.Partrec.Code.exists_code
theorem exists_code {f : ℕ →. ℕ} : Nat.Partrec f ↔ ∃ c : Code, eval c = f 
Arguments: {f : ℕ →. ℕ}
Goal: Nat.Partrec f ↔ ∃ c, c.eval = f
-- Nat.Partrec.Code.evaln_bound
theorem evaln_bound : ∀ {k c n x}, x ∈ evaln k c n → n < k
  
Arguments: {k : ℕ} {c : Nat.Partrec.Code} {n x : ℕ}
Goal: x ∈ Nat.Partrec.Code.evaln k c n → n < k
-- Nat.Partrec.Code.evaln_mono
theorem evaln_mono : ∀ {k₁ k₂ c n x}, k₁ ≤ k₂ → x ∈ evaln k₁ c n → x ∈ evaln k₂ c n
  
Arguments: {k₁ k₂ : ℕ} {c : Nat.Partrec.Code} {n x : ℕ}
Goal: k₁ ≤ k₂ → x ∈ Nat.Partrec.Code.evaln k₁ c n → x ∈ Nat.Partrec.Code.evaln k₂ c n
-- Nat.Partrec.Code.evaln_sound
theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n
  
Arguments: {k : ℕ} {c : Nat.Partrec.Code} {n x : ℕ}
Goal: x ∈ Nat.Partrec.Code.evaln k c n → x ∈ c.eval n
-- Nat.Partrec.Code.evaln_complete
theorem evaln_complete {c n x} : x ∈ eval c n ↔ ∃ k, x ∈ evaln k c n 
Arguments: {c : Nat.Partrec.Code} {n x : ℕ}
Goal: x ∈ c.eval n ↔ ∃ k, x ∈ Nat.Partrec.Code.evaln k c n
-- _private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.hlup
private theorem hlup : Primrec fun p : _ × (_ × _) × _ => lup p.1 p.2.1 p.2.2 
Goal: Primrec fun p => Nat.Partrec.Code.lup p.1 p.2.1 p.2.2
-- _private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.hG
private theorem hG : Primrec G 
Goal: Primrec Nat.Partrec.Code.G
-- _private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_map
private theorem evaln_map (k c n) :
    ((((List.range k)[n]?).map (evaln k c)).bind fun b => b) = evaln k c n 
Arguments: (k : ℕ) (c : Nat.Partrec.Code) (n : ℕ)
Goal: ((Option.map (Nat.Partrec.Code.evaln k c) (List.range k)[n]?).bind fun b => b) = Nat.Partrec.Code.evaln k c n
-- Nat.Partrec.Code.evaln_prim
theorem evaln_prim : Primrec fun a : (ℕ × Code) × ℕ => evaln a.1.1 a.1.2 a.2 
Goal: Primrec fun a => Nat.Partrec.Code.evaln a.1.1 a.1.2 a.2
-- Nat.Partrec.Code.eval_eq_rfindOpt
theorem eval_eq_rfindOpt (c n) : eval c n = Nat.rfindOpt fun k => evaln k c n 
Arguments: (c : Nat.Partrec.Code) (n : ℕ)
Goal: c.eval n = Nat.rfindOpt fun k => Nat.Partrec.Code.evaln k c n
-- Nat.Partrec.Code.eval_part
theorem eval_part : Partrec₂ eval 
Goal: Partrec₂ Nat.Partrec.Code.eval
-- Nat.Partrec.Code.fixed_point
theorem fixed_point {f : Code → Code} (hf : Computable f) : ∃ c : Code, eval (f c) = eval c 
Arguments: {f : Nat.Partrec.Code → Nat.Partrec.Code} (hf : Computable f)
Goal: ∃ c, (f c).eval = c.eval
-- Nat.Partrec.Code.fixed_point₂
theorem fixed_point₂ {f : Code → ℕ →. ℕ} (hf : Partrec₂ f) : ∃ c : Code, eval c = f c 
Arguments: {f : Nat.Partrec.Code → ℕ →. ℕ} (hf : Partrec₂ f)
Goal: ∃ c, c.eval = f c
-- PMF.ext
@[ext]
protected theorem ext {p q : PMF α} (h : ∀ x, p x = q x) : p = q 
Arguments: {α : Type u_1} {p q : PMF α} (h : ∀ (x : α), p x = q x)
Goal: p = q
-- PMF.ext_iff
theorem ext_iff {p q : PMF α} : p = q ↔ ∀ x, p x = q x 
Arguments: {α : Type u_1} {p q : PMF α}
Goal: p = q ↔ ∀ (x : α), p x = q x
-- PMF.hasSum_coe_one
theorem hasSum_coe_one (p : PMF α) : HasSum p 1 
Arguments: {α : Type u_1} (p : PMF α)
Goal: HasSum (⇑p) 1
-- PMF.tsum_coe
@[simp]
theorem tsum_coe (p : PMF α) : ∑' a, p a = 1 
Arguments: {α : Type u_1} (p : PMF α)
Goal: ∑' (a : α), p a = 1
-- PMF.tsum_coe_ne_top
theorem tsum_coe_ne_top (p : PMF α) : ∑' a, p a ≠ ∞ 
Arguments: {α : Type u_1} (p : PMF α)
Goal: ∑' (a : α), p a ≠ ⊤
-- PMF.tsum_coe_indicator_ne_top
theorem tsum_coe_indicator_ne_top (p : PMF α) (s : Set α) : ∑' a, s.indicator p a ≠ ∞ 
Arguments: {α : Type u_1} (p : PMF α) (s : Set α)
Goal: ∑' (a : α), s.indicator (⇑p) a ≠ ⊤
-- PMF.coe_ne_zero
@[simp]
theorem coe_ne_zero (p : PMF α) : ⇑p ≠ 0 
Arguments: {α : Type u_1} (p : PMF α)
Goal: ⇑p ≠ 0