Cauchy_prod.v

Built with Alectryon, running Coq+SerAPI v8.10.0+0.7.0. Coq sources are in this panel; goals and messages will appear in the other. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus.
(************************************************************************)
(*         *   The Coq Proof Assistant / The Coq Development Team       *)
(*  v      *   INRIA, CNRS and contributors - Copyright 1999-2018       *)
(* <O___,, *       (see CREDITS file for the list of authors)           *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)

Require Import Rbase.
Require Import Rfunctions.
Require Import Rseries.
Require Import PartSum.
Local Open Scope R_scope.

  (**********)
Lemma sum_N_predN :
  forall (An:nat -> R) (N:nat),
    (0 < N)%nat -> sum_f_R0 An N = sum_f_R0 An (pred N) + An N.forall (An : nat -> R) (N : nat),
(0 < N)%nat ->
sum_f_R0 An N = sum_f_R0 An (Init.Nat.pred N) + An N
Proof.forall (An : nat -> R) (N : nat),
(0 < N)%nat ->
sum_f_R0 An N = sum_f_R0 An (Init.Nat.pred N) + An N
  intros.An:nat -> R
N:nat
H:(0 < N)%nat
sum_f_R0 An N = sum_f_R0 An (Init.Nat.pred N) + An N
  replace N with (S (pred N)).An:nat -> R
N:nat
H:(0 < N)%nat
sum_f_R0 An (S (Init.Nat.pred N)) =
sum_f_R0 An (Init.Nat.pred (S (Init.Nat.pred N))) +
An (S (Init.Nat.pred N))
An:nat -> R
N:nat
H:(0 < N)%nat
S (Init.Nat.pred N) = N
  rewrite tech5.An:nat -> R
N:nat
H:(0 < N)%nat
sum_f_R0 An (Init.Nat.pred N) +
An (S (Init.Nat.pred N)) =
sum_f_R0 An (Init.Nat.pred (S (Init.Nat.pred N))) +
An (S (Init.Nat.pred N))
An:nat -> R
N:nat
H:(0 < N)%nat
S (Init.Nat.pred N) = N
  reflexivity.An:nat -> R
N:nat
H:(0 < N)%nat
S (Init.Nat.pred N) = N
  symmetry ; apply S_pred with 0%nat; assumption.
Qed.

  (**********)
Lemma sum_plus :
  forall (An Bn:nat -> R) (N:nat),
    sum_f_R0 (fun l:nat => An l + Bn l) N = sum_f_R0 An N + sum_f_R0 Bn N.forall (An Bn : nat -> R) (N : nat),
sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
Proof.forall (An Bn : nat -> R) (N : nat),
sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
  intros.An, Bn:nat -> R
N:nat
sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
  induction  N as [| N HrecN].An, Bn:nat -> R
sum_f_R0 (fun l : nat => An l + Bn l) 0 =
sum_f_R0 An 0 + sum_f_R0 Bn 0
An, Bn:nat -> R
N:nat
HrecN:sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
sum_f_R0 (fun l : nat => An l + Bn l) (S N) =
sum_f_R0 An (S N) + sum_f_R0 Bn (S N)
  reflexivity.An, Bn:nat -> R
N:nat
HrecN:sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
sum_f_R0 (fun l : nat => An l + Bn l) (S N) =
sum_f_R0 An (S N) + sum_f_R0 Bn (S N)
  do 3 rewrite tech5.An, Bn:nat -> R
N:nat
HrecN:sum_f_R0 (fun l : nat => An l + Bn l) N =
sum_f_R0 An N + sum_f_R0 Bn N
sum_f_R0 (fun l : nat => An l + Bn l) N +
(An (S N) + Bn (S N)) =
sum_f_R0 An N + An (S N) + (sum_f_R0 Bn N + Bn (S N))
  rewrite HrecN; ring.
Qed.

  (* The main result *)
Theorem cauchy_finite :
  forall (An Bn:nat -> R) (N:nat),
    (0 < N)%nat ->
    sum_f_R0 An N * sum_f_R0 Bn N =
    sum_f_R0 (fun k:nat => sum_f_R0 (fun p:nat => An p * Bn (k - p)%nat) k) N +
    sum_f_R0
    (fun k:nat =>
      sum_f_R0 (fun l:nat => An (S (l + k)) * Bn (N - l)%nat)
      (pred (N - k))) (pred N).forall (An Bn : nat -> R) (N : nat),
(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) (Init.Nat.pred N)
Proof.forall (An Bn : nat -> R) (N : nat),
(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) (Init.Nat.pred N)
  intros; induction  N as [| N HrecN].An, Bn:nat -> R
H:(0 < 0)%nat
sum_f_R0 An 0 * sum_f_R0 Bn 0 =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  0 +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (0 - l)%nat)
     (Init.Nat.pred (0 - k))) (Init.Nat.pred 0)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) (Init.Nat.pred (S N))
  elim (lt_irrefl _ H).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred (S N))
  cut (N = 0%nat \/ (0 < N)%nat).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat ->
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred (S N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  intro; elim H0; intro.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:N = 0%nat
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred (S N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred (S N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite H1; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred (S N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (S N)) with (S (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0 An (S N) * sum_f_R0 Bn (S N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  (S N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  do 5 rewrite tech5.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(sum_f_R0 An N + An (S N)) *
(sum_f_R0 Bn N + Bn (S N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
(sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
 An (S N) * Bn (S N - S N)%nat) +
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N) +
 sum_f_R0
   (fun l : nat =>
    An (S (l + S (Init.Nat.pred N))) *
    Bn (S N - l)%nat)
   (Init.Nat.pred (S N - S (Init.Nat.pred N))))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite Rmult_plus_distr_r; rewrite Rmult_plus_distr_l; rewrite (HrecN H1).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) + sum_f_R0 An N * Bn (S N) +
An (S N) * (sum_f_R0 Bn N + Bn (S N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0 (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
(sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
 An (S N) * Bn (S N - S N)%nat) +
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N) +
 sum_f_R0
   (fun l : nat =>
    An (S (l + S (Init.Nat.pred N))) *
    Bn (S N - l)%nat)
   (Init.Nat.pred (S N - S (Init.Nat.pred N))))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite Rplus_assoc; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) +
 An (S N) * (sum_f_R0 Bn N + Bn (S N))) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn (S N - S N)%nat +
 (sum_f_R0
    (fun k : nat =>
     sum_f_R0
       (fun l : nat =>
        An (S (l + k)) * Bn (S N - l)%nat)
       (Init.Nat.pred (S N - k))) 
    (Init.Nat.pred N) +
  sum_f_R0
    (fun l : nat =>
     An (S (l + S (Init.Nat.pred N))) *
     Bn (S N - l)%nat)
    (Init.Nat.pred (S N - S (Init.Nat.pred N)))))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (S N - S (pred N))) with 0%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) +
 An (S N) * (sum_f_R0 Bn N + Bn (S N))) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn (S N - S N)%nat +
 (sum_f_R0
    (fun k : nat =>
     sum_f_R0
       (fun l : nat =>
        An (S (l + k)) * Bn (S N - l)%nat)
       (Init.Nat.pred (S N - k))) 
    (Init.Nat.pred N) +
  sum_f_R0
    (fun l : nat =>
     An (S (l + S (Init.Nat.pred N))) *
     Bn (S N - l)%nat) 0))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite Rmult_plus_distr_l;
    replace
      (sum_f_R0 (fun l:nat => An (S (l + S (pred N))) * Bn (S N - l)%nat) 0) with
      (An (S N) * Bn (S N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) +
 (An (S N) * sum_f_R0 Bn N + An (S N) * Bn (S N))) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn (S N - S N)%nat +
 (sum_f_R0
    (fun k : nat =>
     sum_f_R0
       (fun l : nat =>
        An (S (l + k)) * Bn (S N - l)%nat)
       (Init.Nat.pred (S N - k))) 
    (Init.Nat.pred N) + 
  An (S N) * Bn (S N)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite <- Rplus_assoc;
    do 2 rewrite <- (Rplus_comm (An (S N) * Bn (S N)));
      repeat rewrite Rplus_assoc; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn (S N - S N)%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_n_n; cut (N = 1%nat \/ (2 <= N)%nat).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat ->
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  intro; elim H2; intro.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:N = 1%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite H3; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (l + k)) * Bn (N - l)%nat) (pred (N - k)))
      (pred N)) with
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (pred (N - k)))) (pred (pred N)) +
      sum_f_R0 (fun l:nat => An (S l) * Bn (N - l)%nat) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (sum_f_R0 (fun p:nat => An p * Bn (S N - p)%nat) N) with
    (sum_f_R0 (fun l:nat => An (S l) * Bn (N - l)%nat) (pred N) +
      An 0%nat * Bn (S N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite <- Rplus_assoc;
    rewrite <-
      (Rplus_comm (sum_f_R0 (fun l:nat => An (S l) * Bn (N - l)%nat) (pred N)))
      ; repeat rewrite Rplus_assoc; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
An 0%nat * Bn (S N) +
(An (S N) * Bn 0%nat +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (l + k)) * Bn (S N - l)%nat)
      (Init.Nat.pred (S N - k))) 
   (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (l + k)) * Bn (S N - l)%nat)
        (pred (S N - k))) (pred N)) with
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k))) (pred N) +
      Bn (S N) * sum_f_R0 (fun l:nat => An (S l)) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
(sum_f_R0 An N * Bn (S N) + An (S N) * sum_f_R0 Bn N) =
An 0%nat * Bn (S N) +
(An (S N) * Bn 0%nat +
 (sum_f_R0
    (fun k : nat =>
     sum_f_R0
       (fun l : nat =>
        An (S (S (l + k))) * Bn (N - l)%nat)
       (Init.Nat.pred (N - k))) 
    (Init.Nat.pred N) +
  Bn (S N) *
  sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite (decomp_sum An N H1); rewrite Rmult_plus_distr_r;
    repeat rewrite <- Rplus_assoc; rewrite <- (Rplus_comm (An 0%nat * Bn (S N)));
      repeat rewrite Rplus_assoc; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
(sum_f_R0 (fun i : nat => An (S i)) (Init.Nat.pred N) *
 Bn (S N) + An (S N) * sum_f_R0 Bn N) =
An (S N) * Bn 0%nat +
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (S (l + k))) * Bn (N - l)%nat)
      (Init.Nat.pred (N - k))) 
   (Init.Nat.pred N) +
 Bn (S N) *
 sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite <- Rplus_assoc;
    rewrite <-
      (Rplus_comm (sum_f_R0 (fun i:nat => An (S i)) (pred N) * Bn (S N)))
      ;
      rewrite <-
	(Rplus_comm (Bn (S N) * sum_f_R0 (fun i:nat => An (S i)) (pred N)))
	; rewrite (Rmult_comm (Bn (S N))); repeat rewrite Rplus_assoc;
	  apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) * sum_f_R0 Bn N =
An (S N) * Bn 0%nat +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k))) (pred N)) with
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (pred (N - k)))) (pred (pred N)) +
      An (S N) * sum_f_R0 (fun l:nat => Bn (S l)) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) * sum_f_R0 Bn N =
An (S N) * Bn 0%nat +
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (S (l + k))) * Bn (N - l)%nat)
      (Init.Nat.pred (Init.Nat.pred (N - k))))
   (Init.Nat.pred (Init.Nat.pred N)) +
 An (S N) *
 sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite (decomp_sum Bn N H1); rewrite Rmult_plus_distr_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
(An (S N) * Bn 0%nat +
 An (S N) *
 sum_f_R0 (fun i : nat => Bn (S i)) (Init.Nat.pred N)) =
An (S N) * Bn 0%nat +
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       An (S (S (l + k))) * Bn (N - l)%nat)
      (Init.Nat.pred (Init.Nat.pred (N - k))))
   (Init.Nat.pred (Init.Nat.pred N)) +
 An (S N) *
 sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  set
    (Z :=
      sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (pred (N - k)))) (pred (pred N)));
    set (Z2 := sum_f_R0 (fun i:nat => Bn (S i)) (pred N));
      ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite
    (sum_N_predN
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k))) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0
  (fun l : nat =>
   An (S (S (l + Init.Nat.pred N))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k))) (pred (pred N))) with
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (pred (N - k))) + An (S N) * Bn (S k)) (
	  pred (pred N))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0
  (fun l : nat =>
   An (S (S (l + Init.Nat.pred N))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite
    (sum_plus
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (pred (N - k)))) (fun k:nat => An (S N) * Bn (S k))
      (pred (pred N))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0
  (fun l : nat =>
   An (S (S (l + Init.Nat.pred N))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite Rplus_assoc; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0
  (fun l : nat =>
   An (S (S (l + Init.Nat.pred N))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (N - pred N)) with 0%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0
  (fun l : nat =>
   An (S (S (l + Init.Nat.pred N))) * Bn (N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; rewrite <- minus_n_O.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) +
An (S (S (Init.Nat.pred N))) * Bn N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) + 
An (S N) * Bn N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (sum_f_R0 (fun k:nat => An (S N) * Bn (S k)) (pred (pred N))) with
    (sum_f_R0 (fun k:nat => Bn (S k) * An (S N)) (pred (pred N))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) + 
An (S N) * Bn N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- (scal_sum (fun l:nat => Bn (S l)) (pred (pred N)) (An (S N)));
    rewrite (sum_N_predN (fun l:nat => Bn (S l)) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
(sum_f_R0 (fun l : nat => Bn (S l))
   (Init.Nat.pred (Init.Nat.pred N)) +
 Bn (S (Init.Nat.pred N))) =
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l))
  (Init.Nat.pred (Init.Nat.pred N)) + 
An (S N) * Bn N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An (S N) *
(sum_f_R0 (fun l : nat => Bn (S l))
   (Init.Nat.pred (Init.Nat.pred N)) + 
 Bn N) =
An (S N) *
sum_f_R0 (fun l : nat => Bn (S l))
  (Init.Nat.pred (Init.Nat.pred N)) + 
An (S N) * Bn N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_pred; apply lt_le_trans with 2%nat; [ apply lt_n_Sn | assumption ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun k : nat => Bn (S k) * An (S N))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun k : nat => An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros; apply Rmult_comm.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (N - pred N)%nat with 1%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
0%nat = Init.Nat.pred 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
1%nat = (N - Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
1%nat = (N - Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  pattern N at 1; replace N with (S (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
1%nat = (S (Init.Nat.pred N) - Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_Sn_m.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
1%nat = S (Init.Nat.pred N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(Init.Nat.pred N <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_n_n; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(Init.Nat.pred N <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  symmetry ; apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))) +
   An (S N) * Bn (S k))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros;
    rewrite
      (sum_N_predN (fun l:nat => An (S (S (l + i))) * Bn (N - l)%nat)
	(pred (N - i))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S N) * Bn (S i) =
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S (S (Init.Nat.pred (N - i) + i))) *
Bn (N - Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (S (pred (N - i) + i))) with (S N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S N) * Bn (S i) =
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S N) * Bn (N - Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (N - pred (N - i))%nat with (S i).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S N) * Bn (S i) =
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) +
An (S N) * Bn (S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (N - Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (N - Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus; apply INR_eq; repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR (S i) = INR N - (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_le; rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR N - INR i
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_le_reg_l with (INR i - 1).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i - 1 + INR 1 <= INR i - 1 + (INR N - INR i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + INR 1) with (INR i); [ idtac | simpl; ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR i - 1 + (INR N - INR i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + (INR N - INR i)) with (INR N - INR 1);
    [ idtac | simpl; ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR N - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR (N - 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_INR; apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- pred_of_minus; apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with 2%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= 2)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (N - i) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (N - i) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_S_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S (Init.Nat.pred (N - i)) <= S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S (Init.Nat.pred (N - i)) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred (N - i))) with (N - i)%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i)%nat = S (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with i; rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N <= i + N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i)%nat = S (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_plus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i)%nat = S (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N));
    [ assumption | apply le_trans with (pred N); apply le_pred_n ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i)%nat = S (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply plus_lt_reg_l with i; rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i + 0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 0)%nat with i; [ idtac | ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_lt_trans with (pred (pred N));
    [ assumption | apply lt_trans with (pred N); apply lt_pred_n_n ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_S_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_trans with 2%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < 2)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S N = S (S (Init.Nat.pred (N - i) + i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite pred_of_minus; do 3 rewrite S_INR; rewrite plus_INR;
    repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N + 1 = INR N - INR i - INR 1 + INR i + 1 + 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_le.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR (N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR N - INR i
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_le_reg_l with (INR i - 1).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i - 1 + INR 1 <= INR i - 1 + (INR N - INR i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + INR 1) with (INR i); [ idtac | simpl; ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR i - 1 + (INR N - INR i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + (INR N - INR i)) with (INR N - INR 1);
    [ idtac | simpl; ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR N - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR (N - 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with 2%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= 2)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_trans with 1%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_O_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= Init.Nat.pred (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_le.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR (N - i - 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR 1 <= INR N - INR i - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_le_reg_l with (INR i - 1).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i - 1 + INR 1 <=
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + INR 1) with (INR i); [ idtac | simpl; ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (INR i - 1 + (INR N - INR i - INR 1)) with (INR N - INR 1 - INR 1).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR N - INR 1 - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite <- minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR i <= INR (N - 1 - 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N - 1 - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1 - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N - 1 - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  do 2 rewrite <- pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <=
 Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with 1%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 + 1 <= 1 + (N - 1))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 + 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with 2%nat; [ apply le_n_Sn | assumption ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with 2%nat; [ apply le_n_Sn | assumption ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR 1 - INR 1 =
INR i - 1 + (INR N - INR i - INR 1)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with i.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i + 1 <= i + (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i + 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 1)%nat with (S i).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace N with (S (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  symmetry ; apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; rewrite plus_INR; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_trans with 1%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(1 <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_O_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(1 <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_S_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(2 <= S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (l + k)) * Bn (S N - l)%nat)
        (pred (S N - k))) (pred N)) with
    (sum_f_R0
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k)) + An (S k) * Bn (S N)) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)) + 
   An (S k) * Bn (S N)) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)) + 
   An (S k) * Bn (S N)) 
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite
    (sum_plus
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (S (l + k))) * Bn (N - l)%nat)
        (pred (N - k))) (fun k:nat => An (S k) * Bn (S N))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N) +
sum_f_R0 (fun k : nat => An (S k) * Bn (S N))
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)) + 
   An (S k) * Bn (S N)) 
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
Bn (S N) *
sum_f_R0 (fun l : nat => An (S l)) (Init.Nat.pred N) =
sum_f_R0 (fun k : nat => An (S k) * Bn (S N))
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)) + 
   An (S k) * Bn (S N)) 
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite scal_sum; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)) + 
   An (S k) * Bn (S N)) 
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (S N - l)%nat)
     (Init.Nat.pred (S N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros; rewrite Rplus_comm;
    rewrite
      (decomp_sum (fun l:nat => An (S (l + i)) * Bn (S N - l)%nat)
	(pred (S N - i))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
An (S i) * Bn (S N) +
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - i)) =
An (S (0 + i)) * Bn (S N - 0)%nat +
sum_f_R0
  (fun i0 : nat =>
   An (S (S i0 + i)) * Bn (S N - S i0)%nat)
  (Init.Nat.pred (Init.Nat.pred (S N - i)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (0 + i)%nat with i; [ idtac | ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
An (S i) * Bn (S N) +
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - i)) =
An (S i) * Bn (S N - 0)%nat +
sum_f_R0
  (fun i0 : nat =>
   An (S (S i0 + i)) * Bn (S N - S i0)%nat)
  (Init.Nat.pred (Init.Nat.pred (S N - i)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_n_O; apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - i)) =
sum_f_R0
  (fun i0 : nat =>
   An (S (S i0 + i)) * Bn (S N - S i0)%nat)
  (Init.Nat.pred (Init.Nat.pred (S N - i)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (pred (S N - i))) with (pred (N - i)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (N - i)) =
sum_f_R0
  (fun i0 : nat =>
   An (S (S i0 + i)) * Bn (S N - S i0)%nat)
  (Init.Nat.pred (N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
i0:nat
H5:(i0 <= Init.Nat.pred (N - i))%nat
An (S (S (i0 + i))) * Bn (N - i0)%nat =
An (S (S i0 + i)) * Bn (S N - S i0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S N - S i0)%nat with (N - i0)%nat; [ idtac | reflexivity ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
i0:nat
H5:(i0 <= Init.Nat.pred (N - i))%nat
An (S (S (i0 + i))) * Bn (N - i0)%nat =
An (S (S i0 + i)) * Bn (N - i0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S i0 + i)%nat with (S (i0 + i)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
i0:nat
H5:(i0 <= Init.Nat.pred (N - i))%nat
An (S (S (i0 + i))) * Bn (N - i0)%nat =
An (S (S (i0 + i))) * Bn (N - i0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
i0:nat
H5:(i0 <= Init.Nat.pred (N - i))%nat
S (i0 + i) = (S i0 + i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
i0:nat
H5:(i0 <= Init.Nat.pred (N - i))%nat
S (i0 + i) = (S i0 + i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; do 2 rewrite plus_INR; rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  cut ((N - i)%nat = pred (S N - i)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N - i)%nat = Init.Nat.pred (S N - i) ->
Init.Nat.pred (N - i) =
Init.Nat.pred (Init.Nat.pred (S N - i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N - i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  intro; rewrite H5; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N - i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N - i)%nat = (S N - i - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
INR N - INR i = INR (S N) - INR i - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with i.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 1 <= i + (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 1 <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 1)%nat with (S i).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; rewrite plus_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < Init.Nat.pred (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (S N - i)) with (S N - S i)%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < S N - S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S N - S i)%nat with (N - i)%nat; [ idtac | reflexivity ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply plus_lt_reg_l with i.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 0 < i + (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 0)%nat with i; [ idtac | ring ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_lt_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_pred_n_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = Init.Nat.pred (S N - i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S N - S i)%nat = (S N - i - 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
INR (S N) - INR (S i) = INR (S N) - INR i - INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(1 <= S N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with i.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 1 <= i + (S N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i + 1 <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 1)%nat with (S i).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; rewrite plus_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(N <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(S i <= S N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) + An 0%nat * Bn (S N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite Rplus_comm.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An 0%nat * Bn (S N) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0 (fun p : nat => An p * Bn (S N - p)%nat) N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite (decomp_sum (fun p:nat => An p * Bn (S N - p)%nat) N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An 0%nat * Bn (S N) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
An 0%nat * Bn (S N - 0)%nat +
sum_f_R0
  (fun i : nat => An (S i) * Bn (S N - S i)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_n_O.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
An 0%nat * Bn (S N) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
An 0%nat * Bn (S N) +
sum_f_R0
  (fun i : nat => An (S i) * Bn (S N - S i)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun i : nat => An (S i) * Bn (S N - S i)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
An (S i) * Bn (N - i)%nat =
An (S i) * Bn (S N - S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) +
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite Rplus_comm.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k))) 
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite
    (decomp_sum
      (fun k:nat =>
	sum_f_R0 (fun l:nat => An (S (l + k)) * Bn (N - l)%nat) (pred (N - k)))
      (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred (N - 0)) +
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - S i)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- minus_n_O.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - S i)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (sum_f_R0 (fun l:nat => An (S (l + 0)) * Bn (N - l)%nat) (pred N))
    with (sum_f_R0 (fun l:nat => An (S l) * Bn (N - l)%nat) (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) +
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - S i)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply Rplus_eq_compat_l.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (S (l + k))) * Bn (N - l)%nat)
     (Init.Nat.pred (Init.Nat.pred (N - k))))
  (Init.Nat.pred (Init.Nat.pred N)) =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - S i)))
  (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) =
sum_f_R0
  (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
  (Init.Nat.pred (N - S i))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (pred (N - S i)) with (pred (pred (N - i))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
sum_f_R0
  (fun l : nat => An (S (S (l + i))) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i))) =
sum_f_R0
  (fun l : nat => An (S (l + S i)) * Bn (N - l)%nat)
  (Init.Nat.pred (Init.Nat.pred (N - i)))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
i0:nat
H5:(i0 <= Init.Nat.pred (Init.Nat.pred (N - i)))%nat
An (S (S (i0 + i))) * Bn (N - i0)%nat =
An (S (i0 + S i)) * Bn (N - i0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i0 + S i)%nat with (S (i0 + i)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
i0:nat
H5:(i0 <= Init.Nat.pred (Init.Nat.pred (N - i)))%nat
An (S (S (i0 + i))) * Bn (N - i0)%nat =
An (S (S (i0 + i))) * Bn (N - i0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
i0:nat
H5:(i0 <= Init.Nat.pred (Init.Nat.pred (N - i)))%nat
S (i0 + i) = (i0 + S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
i0:nat
H5:(i0 <= Init.Nat.pred (Init.Nat.pred (N - i)))%nat
S (i0 + i) = (i0 + S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; do 2 rewrite plus_INR; rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  cut (pred (N - i) = (N - S i)%nat).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (N - i) = (N - S i)%nat ->
Init.Nat.pred (Init.Nat.pred (N - i)) =
Init.Nat.pred (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (N - i) = (N - S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  intro; rewrite H5; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred (N - i) = (N - S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(N - i - 1)%nat = (N - S i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR (N - i - 1) = INR (N - S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
INR N - INR i - INR 1 = INR N - INR (S i)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  repeat rewrite S_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (S (pred (pred N))).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= S (Init.Nat.pred (Init.Nat.pred N)))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S (Init.Nat.pred (Init.Nat.pred N)) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S (Init.Nat.pred (Init.Nat.pred N)) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred (pred N))) with (pred N).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred N <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred N = S (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
Init.Nat.pred N = S (Init.Nat.pred (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_S_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_trans with 2%nat.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 < 2)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_n_Sn.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(1 <= N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply (fun p n m:nat => plus_le_reg_l n m p) with i.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i + 1 <= i + (N - i))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite le_plus_minus_r.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i + 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 1)%nat with (S i).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace N with (S (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(S i <= S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_n_S.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S (Init.Nat.pred N) = N
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  symmetry ; apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
S i = (i + 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; rewrite S_INR; rewrite plus_INR; simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred (pred N)).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(i <= Init.Nat.pred (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred (Init.Nat.pred N))%nat
(Init.Nat.pred (Init.Nat.pred N) <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply le_trans with (pred N); apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
sum_f_R0 (fun l : nat => An (S l) * Bn (N - l)%nat)
  (Init.Nat.pred N) =
sum_f_R0
  (fun l : nat => An (S (l + 0)) * Bn (N - l)%nat)
  (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply sum_eq; intros.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
i:nat
H4:(i <= Init.Nat.pred N)%nat
An (S i) * Bn (N - i)%nat =
An (S (i + 0)) * Bn (N - i)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (i + 0)%nat with i; [ reflexivity | trivial ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(0 < Init.Nat.pred N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_S_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(1 < S (Init.Nat.pred N))%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
(1 < N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_trans with 2%nat; [ apply lt_n_Sn | assumption ].An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:N = 1%nat \/ (2 <= N)%nat
H3:(2 <= N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = 1%nat \/ (2 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  inversion H1.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
H2:1%nat = N
1%nat = 1%nat \/ (2 <= 1)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
m:nat
H2:(1 <= m)%nat
H3:S m = N
S m = 1%nat \/ (2 <= S m)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  left; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
m:nat
H2:(1 <= m)%nat
H3:S m = N
S m = 1%nat \/ (2 <= S m)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  right; apply le_n_S; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
sum_f_R0
  (fun l : nat =>
   An (S (l + S (Init.Nat.pred N))) * Bn (S N - l)%nat)
  0
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) =
An (S (S (Init.Nat.pred N))) * Bn (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  replace (S (pred N)) with N.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
An (S N) * Bn (S N) = An (S N) * Bn (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
N = S (Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (S N - S (Init.Nat.pred N))
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  cut ((N - pred N)%nat = 1%nat).An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - Init.Nat.pred N)%nat = 1%nat ->
0%nat = Init.Nat.pred (N - Init.Nat.pred N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - Init.Nat.pred N)%nat = 1%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  intro; rewrite H2; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - Init.Nat.pred N)%nat = 1%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite pred_of_minus.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - (N - 1))%nat = 1%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply INR_eq; repeat rewrite minus_INR.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
INR N - (INR N - INR 1) = INR 1
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; ring.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  apply lt_le_S; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
(N - 1 <= N)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  rewrite <- pred_of_minus; apply le_pred_n.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H0:N = 0%nat \/ (0 < N)%nat
H1:(0 < N)%nat
S (Init.Nat.pred N) = Init.Nat.pred (S N)
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  simpl; symmetry ; apply S_pred with 0%nat; assumption.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
N = 0%nat \/ (0 < N)%nat
  inversion H.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
H1:0%nat = N
0%nat = 0%nat \/ (0 < 0)%nat
An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
m:nat
H1:(1 <= N)%nat
H0:m = N
N = 0%nat \/ (0 < N)%nat
  left; reflexivity.An, Bn:nat -> R
N:nat
H:(0 < S N)%nat
HrecN:(0 < N)%nat ->
sum_f_R0 An N * sum_f_R0 Bn N =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat => An p * Bn (k - p)%nat) k)
  N +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      An (S (l + k)) * Bn (N - l)%nat)
     (Init.Nat.pred (N - k)))
  (Init.Nat.pred N)
m:nat
H1:(1 <= N)%nat
H0:m = N
N = 0%nat \/ (0 < N)%nat
  right; apply lt_le_trans with 1%nat; [ apply lt_n_Sn | exact H1 ].
Qed.