Theorem: Bind.bind.arg_a0a1.revDerivM_rule (SciLean/Core/Monads/RevDerivMonad.lean)

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
⊢ (revDerivM K fun x => a0 x >>= a1 x) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
let g := fun x => do
  let y ← a0 x
  pure (x,y)
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
⊢ (revDerivM K fun x => a0 x >>= a1 x) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
⊢ (revDerivM K fun x => a0 x >>= a1 x) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
let f := fun xy : X×Y => a1 xy.1 xy.2
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ (revDerivM K fun x => a0 x >>= a1 x) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ (revDerivM K fun x => a0 x >>= a1 x) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
rw[show (fun x => Bind.bind (a0 x) (a1 x))
        =
        fun x => g x >>= f by simp[f,g]]
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
have hg : HasAdjDiffM K (fun x => do let y ← a0 x; pure (x,y)) :=
  by apply RevDerivMonad.HasAdjDiffM_pair a0 ha0
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
have hf : HasAdjDiffM K f := by fun_prop
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
hf : HasAdjDiffM K f
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
hf : HasAdjDiffM K f
⊢ (revDerivM K fun x => g x >>= f) = fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
rw [RevDerivMonad.revDerivM_bind _ _ hf hg]
State after:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
hf : HasAdjDiffM K f
⊢ (fun x => do
      let ydg ←
        revDerivM K
            (fun x => do
              let y ← a0 x
              pure (x, y))
            x
      let zdf ← revDerivM K f ydg.1
      pure (zdf.1, fun dz => zdf.2 dz >>= ydg.2)) =
    fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
hf : HasAdjDiffM K f
⊢ (fun x => do
      let ydg ←
        revDerivM K
            (fun x => do
              let y ← a0 x
              pure (x, y))
            x
      let zdf ← revDerivM K f ydg.1
      pure (zdf.1, fun dz => zdf.2 dz >>= ydg.2)) =
    fun x => do
    let ydg ← revDerivM K a0 x
    let zdf ← revDerivM K (fun xy => a1 xy.1 xy.2) (x, ydg.1)
    pure
        (zdf.1, fun dz => do
          let dxy ← zdf.2 dz
          let dx ← ydg.2 dxy.2
          pure (dxy.1 + dx))
Tactic:
simp [RevDerivMonad.revDerivM_pair a0 ha0]
State after:
no goals

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ (fun x => a0 x >>= a1 x) = fun x => g x >>= f
Tactic:
simp[f,g]
State after:
no goals

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
⊢ HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
Tactic:
apply RevDerivMonad.HasAdjDiffM_pair a0 ha0
State after:
no goals

State before:
ι : Sort ?u.69718
K : Type
inst✝⁹ : RCLike K
m m' : Type → Type
inst✝⁸ : Monad m
inst✝⁷ : Monad m'
inst✝⁶ : RevDerivMonad K m m'
inst✝⁵ : LawfulMonad m
inst✝⁴ : LawfulMonad m'
X : Type
inst✝³ : SemiInnerProductSpace K X
Y : Type
inst✝² : SemiInnerProductSpace K Y
Z : Type
inst✝¹ : SemiInnerProductSpace K Z
E : ι → Type
inst✝ : (i : ι) → SemiInnerProductSpace K (E i)
a0 : X → m Y
a1 : X → Y → m Z
ha0 : HasAdjDiffM K a0
ha1 : HasAdjDiffM K fun xy => a1 xy.1 xy.2
g : X → m (X × Y) :=
  fun x => do
    let y ← a0 x
    pure (x, y)
f : X × Y → m Z := fun xy => a1 xy.1 xy.2
hg :
  HasAdjDiffM K fun x => do
    let y ← a0 x
    pure (x, y)
⊢ HasAdjDiffM K f
Tactic:
fun_prop
State after:
no goals