Theorem: SciLean.Prob.FDRand.bind_pure (SciLean/Modules/Prob/FDRand.lean)

State before:
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ bind (fdpure x dx) f = { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }
Tactic:
simp only [bind,fdpure]
State after:
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
      val :=
        let x' ~ Rand.pure x
        (f x').val,
      dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval } =
    { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }

State before:
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
      val :=
        let x' ~ Rand.pure x
        (f x').val,
      dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval } =
    { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }
Tactic:
apply ext
State after:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }.val

case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval =
    {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval

State before:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }.val

case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval =
    {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval
Tactic:
. simp (disch:=sorry) only [rand_simp]
State after:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval =
    {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval

State before:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval =
    {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval
Tactic:
. simp only [rand_simp]
State after:
no goals

State before:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    { val := (f x).val, dval := randDeriv (fun x' => (f x').val) x dx + (f x).dval }.val
Tactic:
simp (disch:=sorry) only [rand_simp]
State after:
no goals

State before:
case a
R : Type ?u.7135
inst✝¹⁶ : RealScalar R
X : Type
inst✝¹⁵ : NormedAddCommGroup X
inst✝¹⁴ : NormedSpace ℝ X
inst✝¹³ : NormedSpace R X
inst✝¹² : MeasurableSpace X
Y : Type
inst✝¹¹ : NormedAddCommGroup Y
inst✝¹⁰ : NormedSpace ℝ Y
inst✝⁹ : NormedSpace R Y
inst✝⁸ : MeasurableSpace Y
Z : Type
inst✝⁷ : NormedAddCommGroup Z
inst✝⁶ : NormedSpace ℝ Z
inst✝⁵ : NormedSpace R Z
inst✝⁴ : MeasurableSpace Z
W : Type
inst✝³ : NormedAddCommGroup W
inst✝² : NormedSpace ℝ W
inst✝¹ : NormedSpace R W
inst✝ : MeasurableSpace W
f : X → FDRand Y
x dx : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval =
    {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x dx) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval
Tactic:
simp only [rand_simp]
State after:
no goals