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

State before:
R : Type ?u.8427
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 : X
⊢ bind (fdpure x 0) f = f x
Tactic:
simp only [bind,fdpure]
State after:
R : Type ?u.8427
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 : X
⊢ {
      val :=
        let x' ~ Rand.pure x
        (f x').val,
      dval := (DRand.bindDR (dpure x 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval } =
    f x

State before:
R : Type ?u.8427
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 : X
⊢ {
      val :=
        let x' ~ Rand.pure x
        (f x').val,
      dval := (DRand.bindDR (dpure x 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval } =
    f x
Tactic:
apply ext
State after:
case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    (f x).val

case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) 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 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval

State before:
case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    (f x).val

case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) 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 0) 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.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) 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 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval

State before:
case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) 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 0) 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.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.val =
    (f x).val
Tactic:
simp (disch:=sorry) only [rand_simp]
State after:
no goals

State before:
case a
R : Type ?u.8427
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 : X
⊢ {
        val :=
          let x' ~ Rand.pure x
          (f x').val,
        dval := (DRand.bindDR (dpure x 0) 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 0) fun x' => (f x').val) + bindRD (Rand.pure x) fun x' => (f x').dval }.dval
Tactic:
simp only [rand_simp]
State after:
no goals