Cos_rel.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 SeqSeries.
Require Import Rtrigo_def.
Require Import OmegaTactic.
Local Open Scope R_scope.

Definition A1 (x:R) (N:nat) : R :=
  sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) N.

Definition B1 (x:R) (N:nat) : R :=
  sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
    N.

Definition C1 (x y:R) (N:nat) : R :=
  sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * (x + y) ^ (2 * k)) N.

Definition Reste1 (x y:R) (N:nat) : R :=
  sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun l:nat =>
            (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
            x ^ (2 * S (l + k)) * ((-1) ^ (N - l) / INR (fact (2 * (N - l)))) *
            y ^ (2 * (N - l))) (pred (N - k))) (pred N).

Definition Reste2 (x y:R) (N:nat) : R :=
  sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun l:nat =>
            (-1) ^ S (l + k) / INR (fact (2 * S (l + k) + 1)) *
            x ^ (2 * S (l + k) + 1) *
            ((-1) ^ (N - l) / INR (fact (2 * (N - l) + 1))) *
            y ^ (2 * (N - l) + 1)) (pred (N - k))) (
    pred N).

Definition Reste (x y:R) (N:nat) : R := Reste2 x y N - Reste1 x y (S N).

(* Here is the main result that will be used to prove that (cos (x+y))=(cos x)(cos y)-(sin x)(sin y) *)
Theorem cos_plus_form :
 forall (x y:R) (n:nat),
   (0 < n)%nat ->
   A1 x (S n) * A1 y (S n) - B1 x n * B1 y n + Reste x y n = C1 x y (S n).forall (x y : R) (n : nat),
(0 < n)%nat ->
A1 x (S n) * A1 y (S n) - B1 x n * B1 y n +
Reste x y n = C1 x y (S n)
Proof.forall (x y : R) (n : nat),
(0 < n)%nat ->
A1 x (S n) * A1 y (S n) - B1 x n * B1 y n +
Reste x y n = C1 x y (S n)
intros.x, y:R
n:nat
H:(0 < n)%nat
A1 x (S n) * A1 y (S n) - B1 x n * B1 y n +
Reste x y n = C1 x y (S n)
unfold A1, B1.x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) (S n) *
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * y ^ (2 * k)) (S n) -
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n *
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * y ^ (2 * k + 1))
  n + Reste x y n = C1 x y (S n)
rewrite
 (cauchy_finite (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k))
    (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * y ^ (2 * k)) (
    S n)).x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n)) -
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n *
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * y ^ (2 * k + 1))
  n + Reste x y n = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite
 (cauchy_finite
    (fun k:nat => (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
    (fun k:nat => (-1) ^ k / INR (fact (2 * k + 1)) * y ^ (2 * k + 1)) n H)
 .x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n)) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       (-1) ^ S (l + k) /
       INR (fact (2 * S (l + k) + 1)) *
       x ^ (2 * S (l + k) + 1) *
       ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
        y ^ (2 * (n - l) + 1)))
      (Init.Nat.pred (n - k))) (Init.Nat.pred n)) +
Reste x y n = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Reste.x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n) +
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n)) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       (-1) ^ S (l + k) /
       INR (fact (2 * S (l + k) + 1)) *
       x ^ (2 * S (l + k) + 1) *
       ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
        y ^ (2 * (n - l) + 1)))
      (Init.Nat.pred (n - k))) (Init.Nat.pred n)) +
(Reste2 x y n - Reste1 x y (S n)) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun l:nat =>
            (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
            x ^ (2 * S (l + k)) *
            ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
             y ^ (2 * (S n - l)))) (pred (S n - k))) (
    pred (S n))) with (Reste1 x y (S n)).x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n) + Reste1 x y (S n) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n +
 sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun l : nat =>
       (-1) ^ S (l + k) /
       INR (fact (2 * S (l + k) + 1)) *
       x ^ (2 * S (l + k) + 1) *
       ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
        y ^ (2 * (n - l) + 1)))
      (Init.Nat.pred (n - k))) (Init.Nat.pred n)) +
(Reste2 x y n - Reste1 x y (S n)) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun l:nat =>
            (-1) ^ S (l + k) / INR (fact (2 * S (l + k) + 1)) *
            x ^ (2 * S (l + k) + 1) *
            ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
             y ^ (2 * (n - l) + 1))) (pred (n - k))) (
    pred n)) with (Reste2 x y n).x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n) + Reste1 x y (S n) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n + Reste2 x y n) +
(Reste2 x y n - Reste1 x y (S n)) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) (Init.Nat.pred (n - k)))
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun p:nat =>
            (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
            ((-1) ^ (k - p) / INR (fact (2 * (k - p))) * y ^ (2 * (k - p))))
         k) (S n)) with
 (sum_f_R0
    (fun k:nat =>
       (-1) ^ k / INR (fact (2 * k)) *
       sum_f_R0
         (fun l:nat => C (2 * k) (2 * l) * x ^ (2 * l) * y ^ (2 * (k - l))) k)
    (S n)).x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) (S n) + Reste1 x y (S n) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n + Reste2 x y n) +
(Reste2 x y n - Reste1 x y (S n)) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) (Init.Nat.pred (n - k)))
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) (Init.Nat.pred (S n - k)))
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
pose
 (sin_nnn :=
  fun n:nat =>
    match n with
    | O => 0
    | S p =>
        (-1) ^ S p / INR (fact (2 * S p)) *
        sum_f_R0
          (fun l:nat =>
             C (2 * S p) (S (2 * l)) * x ^ S (2 * l) * y ^ S (2 * (p - l))) p
    end).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) (S n) + Reste1 x y (S n) -
(sum_f_R0
   (fun k : nat =>
    sum_f_R0
      (fun p : nat =>
       (-1) ^ p / INR (fact (2 * p + 1)) *
       x ^ (2 * p + 1) *
       ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
        y ^ (2 * (k - p) + 1))) k) n + Reste2 x y n) +
(Reste2 x y n - Reste1 x y (S n)) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
ring_simplify.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) -
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n = 
C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rminus.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) +
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n = 
C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
(* (-   old ring compat *)
 (-
  sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun p:nat =>
            (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
            ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
             y ^ (2 * (k - p) + 1))) k) n) with (sum_f_R0 sin_nnn (S n)).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) + sum_f_R0 sin_nnn (S n) = 
C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- sum_plus.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun l : nat =>
   (-1) ^ l / INR (fact (2 * l)) *
   sum_f_R0
     (fun l0 : nat =>
      C (2 * l) (2 * l0) * x ^ (2 * l0) *
      y ^ (2 * (l - l0))) l + 
   sin_nnn l) (S n) = C1 x y (S n)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold C1.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0
  (fun l : nat =>
   (-1) ^ l / INR (fact (2 * l)) *
   sum_f_R0
     (fun l0 : nat =>
      C (2 * l) (2 * l0) * x ^ (2 * l0) *
      y ^ (2 * (l - l0))) l + 
   sin_nnn l) (S n) =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * (x + y) ^ (2 * k))
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= S n)%nat
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) * y ^ (2 * (i - l)))
  i + sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) * (x + y) ^ (2 * i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
induction  i as [| i Hreci].x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
H0:(0 <= S n)%nat
(-1) ^ 0 / INR (fact (2 * 0)) *
sum_f_R0
  (fun l : nat =>
   C (2 * 0) (2 * l) * x ^ (2 * l) * y ^ (2 * (0 - l)))
  0 + sin_nnn 0%nat =
(-1) ^ 0 / INR (fact (2 * 0)) * (x + y) ^ (2 * 0)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) + sin_nnn (S i) =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
simpl.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
H0:(0 <= S n)%nat
1 / 1 * (C 0 0 * 1 * 1) + 0 = 1 / 1 * 1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) + sin_nnn (S i) =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold C; simpl.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
H0:(0 <= S n)%nat
1 / 1 * (1 / (1 * 1) * 1 * 1) + 0 = 1 / 1 * 1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) + sin_nnn (S i) =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
field; discrR.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) + sin_nnn (S i) =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold sin_nnn.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) +
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- Rmult_plus_distr_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
(-1) ^ S i / INR (fact (2 * S i)) *
(sum_f_R0
   (fun l : nat =>
    C (2 * S i) (2 * l) * x ^ (2 * l) *
    y ^ (2 * (S i - l))) 
   (S i) +
 sum_f_R0
   (fun l : nat =>
    C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
    y ^ S (2 * (i - l))) i) =
(-1) ^ S i / INR (fact (2 * S i)) *
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply Rmult_eq_compat_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) +
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i = 
(x + y) ^ (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite binomial.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) +
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i =
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0))
  (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
pose (Wn := fun i0:nat => C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0)).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i) +
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i =
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0))
  (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (sum_f_R0
    (fun l:nat => C (2 * S i) (2 * l) * x ^ (2 * l) * y ^ (2 * (S i - l)))
    (S i)) with (sum_f_R0 (fun l:nat => Wn (2 * l)%nat) (S i)).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) +
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i =
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0))
  (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (sum_f_R0
    (fun l:nat =>
       C (2 * S i) (S (2 * l)) * x ^ S (2 * l) * y ^ S (2 * (i - l))) i) with
 (sum_f_R0 (fun l:nat => Wn (S (2 * l))) i).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) +
sum_f_R0 (fun l : nat => Wn (S (2 * l))) i =
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0))
  (2 * S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (S (2 * l))) i =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_decomposition.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (S (2 * l))) i =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
Wn (S (2 * i0)) =
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ S (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Wn.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ (2 * S i - S (2 * i0)) =
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ S (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply Rmult_eq_compat_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
y ^ (2 * S i - S (2 * i0)) = y ^ S (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (2 * S i - S (2 * i0))%nat with (S (2 * (i - i0))).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
y ^ S (2 * (i - i0)) = y ^ S (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
S (2 * (i - i0)) = (2 * S i - S (2 * i0))%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
reflexivity.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= i)%nat
S (2 * (i - i0)) = (2 * S i - S (2 * i0))%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
omega.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i0 : nat =>
C (2 * S i) i0 * x ^ i0 * y ^ (2 * S i - i0):nat -> R
sum_f_R0 (fun l : nat => Wn (2 * l)%nat) (S i) =
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (S i - l))) 
  (S i)
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
Wn (2 * i0)%nat =
C (2 * S i) (2 * i0) * x ^ (2 * i0) *
y ^ (2 * (S i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Wn.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
C (2 * S i) (2 * i0) * x ^ (2 * i0) *
y ^ (2 * S i - 2 * i0) =
C (2 * S i) (2 * i0) * x ^ (2 * i0) *
y ^ (2 * (S i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply Rmult_eq_compat_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
y ^ (2 * S i - 2 * i0) = y ^ (2 * (S i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (2 * S i - 2 * i0)%nat with (2 * (S i - i0))%nat.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
y ^ (2 * (S i - i0)) = y ^ (2 * (S i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
(2 * (S i - i0))%nat = (2 * S i - 2 * i0)%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
reflexivity.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(S i <= S n)%nat
Hreci:(i <= S n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) *
   y ^ (2 * (i - l))) i + 
sin_nnn i =
(-1) ^ i / INR (fact (2 * i)) *
(x + y) ^ (2 * i)
Wn:=fun i1 : nat =>
C (2 * S i) i1 * x ^ i1 * y ^ (2 * S i - i1):nat -> R
i0:nat
H1:(i0 <= S i)%nat
(2 * (S i - i0))%nat = (2 * S i - 2 * i0)%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
omega.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace
 (-
  sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun p:nat =>
            (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
            ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
             y ^ (2 * (k - p) + 1))) k) n) with
 (-1 *
  sum_f_R0
    (fun k:nat =>
       sum_f_R0
         (fun p:nat =>
            (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
            ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
             y ^ (2 * (k - p) + 1))) k) n);[idtac|ring].x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
-1 *
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p) + 1)) *
       y ^ (2 * (k - p) + 1))) k) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite scal_sum.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 sin_nnn (S n) =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
       y ^ (2 * (i - p) + 1))) i * -1) n
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite decomp_sum.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sin_nnn 0%nat +
sum_f_R0 (fun i : nat => sin_nnn (S i))
  (Init.Nat.pred (S n)) =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
       y ^ (2 * (i - p) + 1))) i * -1) n
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (sin_nnn 0%nat) with 0.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 +
sum_f_R0 (fun i : nat => sin_nnn (S i))
  (Init.Nat.pred (S n)) =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
       y ^ (2 * (i - p) + 1))) i * -1) n
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rplus_0_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 (fun i : nat => sin_nnn (S i))
  (Init.Nat.pred (S n)) =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
       y ^ (2 * (i - p) + 1))) i * -1) n
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
change (pred (S n)) with n.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
sum_f_R0 (fun i : nat => sin_nnn (S i)) n =
sum_f_R0
  (fun i : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p + 1)) *
      x ^ (2 * p + 1) *
      ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
       y ^ (2 * (i - p) + 1))) i * -1) n
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
   (* replace (pred (S n)) with n; [ idtac | reflexivity ]. *)
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
sin_nnn (S i) =
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
    y ^ (2 * (i - p) + 1))) i * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rmult_comm.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
sin_nnn (S i) =
-1 *
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
    y ^ (2 * (i - p) + 1))) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold sin_nnn.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
(-1) ^ S i / INR (fact (2 * S i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * S i) (S (2 * l)) * x ^ S (2 * l) *
   y ^ S (2 * (i - l))) i =
-1 *
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
    y ^ (2 * (i - p) + 1))) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite scal_sum.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
   y ^ S (2 * (i - i0)) *
   ((-1) ^ S i / INR (fact (2 * S i)))) i =
-1 *
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p + 1)) * x ^ (2 * p + 1) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p) + 1)) *
    y ^ (2 * (i - p) + 1))) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite scal_sum.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
sum_f_R0
  (fun i0 : nat =>
   C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
   y ^ S (2 * (i - i0)) *
   ((-1) ^ S i / INR (fact (2 * S i)))) i =
sum_f_R0
  (fun i0 : nat =>
   (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
   x ^ (2 * i0 + 1) *
   ((-1) ^ (i - i0) / INR (fact (2 * (i - i0) + 1)) *
    y ^ (2 * (i - i0) + 1)) * -1) i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ S (2 * (i - i0)) *
((-1) ^ S i / INR (fact (2 * S i))) =
(-1) ^ i0 / INR (fact (2 * i0 + 1)) * x ^ (2 * i0 + 1) *
((-1) ^ (i - i0) / INR (fact (2 * (i - i0) + 1)) *
 y ^ (2 * (i - i0) + 1)) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ S (2 * (i - i0)) *
((-1) ^ S i * / INR (fact (2 * S i))) =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) *
((-1) ^ (i - i0) * / INR (fact (2 * (i - i0) + 1)) *
 y ^ (2 * (i - i0) + 1)) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
(*repeat rewrite Rmult_assoc.*)
(* rewrite (Rmult_comm (/ INR (fact (2 * S i)))). *)
repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
y ^ S (2 * (i - i0)) * (-1) ^ S i *
/ INR (fact (2 * S i)) =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- (Rmult_comm (/ INR (fact (2 * S i)))).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * S i)) *
(C (2 * S i) (S (2 * i0)) * x ^ S (2 * i0) *
 y ^ S (2 * (i - i0)) * 
 (-1) ^ S i) =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0)) *
x ^ S (2 * i0) * y ^ S (2 * (i - i0)) * 
(-1) ^ S i =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))) with
 (/ INR (fact (2 * i0 + 1)) * / INR (fact (2 * (i - i0) + 1))).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) * 
x ^ S (2 * i0) * y ^ S (2 * (i - i0)) * 
(-1) ^ S i =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (S (2 * i0)) with (2 * i0 + 1)%nat; [ idtac | ring ].x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) * 
x ^ (2 * i0 + 1) * y ^ S (2 * (i - i0)) * 
(-1) ^ S i =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (S (2 * (i - i0))) with (2 * (i - i0) + 1)%nat; [ idtac | ring ].x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) * 
x ^ (2 * i0 + 1) * y ^ (2 * (i - i0) + 1) * 
(-1) ^ S i =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace ((-1) ^ S i) with (-1 * (-1) ^ i0 * (-1) ^ (i - i0)).x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) * 
x ^ (2 * i0 + 1) * y ^ (2 * (i - i0) + 1) *
(-1 * (-1) ^ i0 * (-1) ^ (i - i0)) =
(-1) ^ i0 * / INR (fact (2 * i0 + 1)) *
x ^ (2 * i0 + 1) * (-1) ^ (i - i0) *
/ INR (fact (2 * (i - i0) + 1)) *
y ^ (2 * (i - i0) + 1) * -1
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
-1 * (-1) ^ i0 * (-1) ^ (i - i0) = (-1) ^ S i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
ring.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
-1 * (-1) ^ i0 * (-1) ^ (i - i0) = (-1) ^ S i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
simpl.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
-1 * (-1) ^ i0 * (-1) ^ (i - i0) = -1 * (-1) ^ i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
pattern i at 2; replace i with (i0 + (i - i0))%nat.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
-1 * (-1) ^ i0 * (-1) ^ (i - i0) =
-1 * (-1) ^ (i0 + (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite pow_add.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
-1 * (-1) ^ i0 * (-1) ^ (i - i0) =
-1 * ((-1) ^ i0 * (-1) ^ (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
ring.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
symmetry ; apply le_plus_minus; assumption.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * C (2 * S i) (S (2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold C.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) *
(INR (fact (2 * S i)) /
 (INR (fact (S (2 * i0))) *
  INR (fact (2 * S i - S (2 * i0)))))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv; repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i)) * INR (fact (2 * S i)) *
/
(INR (fact (S (2 * i0))) *
 INR (fact (2 * S i - S (2 * i0))))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- Rinv_l_sym.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
1 *
/
(INR (fact (S (2 * i0))) *
 INR (fact (2 * S i - S (2 * i0))))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rmult_1_l.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/
(INR (fact (S (2 * i0))) *
 INR (fact (2 * S i - S (2 * i0))))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rinv_mult_distr.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0 + 1)) *
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (S (2 * i0))) *
/ INR (fact (2 * S i - S (2 * i0)))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (S (2 * i0)) with (2 * i0 + 1)%nat;
 [ apply Rmult_eq_compat_l | ring ].x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * S i - (2 * i0 + 1)))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (2 * S i - (2 * i0 + 1))%nat with (2 * (i - i0) + 1)%nat.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * (i - i0) + 1)) =
/ INR (fact (2 * (i - i0) + 1))
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
(2 * (i - i0) + 1)%nat = (2 * S i - (2 * i0 + 1))%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
reflexivity.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
(2 * (i - i0) + 1)%nat = (2 * S i - (2 * i0 + 1))%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
omega.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i - S (2 * i0))) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
i:nat
H0:(i <= n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * S i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
0 = sin_nnn 0%nat
x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
reflexivity.x, y:R
n:nat
H:(0 < n)%nat
sin_nnn:=fun n0 : nat =>
match n0 with
| 0%nat => 0
| S p =>
    (-1) ^ S p / INR (fact (2 * S p)) *
    sum_f_R0
      (fun l : nat =>
       C (2 * S p) (S (2 * l)) *
       x ^ S (2 * l) * y ^ S (2 * (p - l))) p
end:nat -> R
(0 < S n)%nat
x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply lt_O_Sn.x, y:R
n:nat
H:(0 < n)%nat
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) *
   sum_f_R0
     (fun l : nat =>
      C (2 * k) (2 * l) * x ^ (2 * l) *
      y ^ (2 * (k - l))) k) 
  (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun p : nat =>
      (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
      ((-1) ^ (k - p) / INR (fact (2 * (k - p))) *
       y ^ (2 * (k - p)))) k) 
  (S n)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
(* ring. *)
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
(-1) ^ i / INR (fact (2 * i)) *
sum_f_R0
  (fun l : nat =>
   C (2 * i) (2 * l) * x ^ (2 * l) * y ^ (2 * (i - l)))
  i =
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p))) *
    y ^ (2 * (i - p)))) i
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite scal_sum.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
sum_f_R0
  (fun i0 : nat =>
   C (2 * i) (2 * i0) * x ^ (2 * i0) *
   y ^ (2 * (i - i0)) *
   ((-1) ^ i / INR (fact (2 * i)))) i =
sum_f_R0
  (fun p : nat =>
   (-1) ^ p / INR (fact (2 * p)) * x ^ (2 * p) *
   ((-1) ^ (i - p) / INR (fact (2 * (i - p))) *
    y ^ (2 * (i - p)))) i
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * i) (2 * i0) * x ^ (2 * i0) * y ^ (2 * (i - i0)) *
((-1) ^ i / INR (fact (2 * i))) =
(-1) ^ i0 / INR (fact (2 * i0)) * x ^ (2 * i0) *
((-1) ^ (i - i0) / INR (fact (2 * (i - i0))) *
 y ^ (2 * (i - i0)))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * i) (2 * i0) * x ^ (2 * i0) * y ^ (2 * (i - i0)) *
((-1) ^ i * / INR (fact (2 * i))) =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
((-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
 y ^ (2 * (i - i0)))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
C (2 * i) (2 * i0) * x ^ (2 * i0) * y ^ (2 * (i - i0)) *
(-1) ^ i * / INR (fact (2 * i)) =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
(-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
y ^ (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- (Rmult_comm (/ INR (fact (2 * i)))).x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i)) *
(C (2 * i) (2 * i0) * x ^ (2 * i0) *
 y ^ (2 * (i - i0)) * (-1) ^ i) =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
(-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
y ^ (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i)) * C (2 * i) (2 * i0) *
x ^ (2 * i0) * y ^ (2 * (i - i0)) * 
(-1) ^ i =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
(-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
y ^ (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (/ INR (fact (2 * i)) * C (2 * i) (2 * i0)) with
 (/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0)))).x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) *
x ^ (2 * i0) * y ^ (2 * (i - i0)) * 
(-1) ^ i =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
(-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
y ^ (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace ((-1) ^ i) with ((-1) ^ i0 * (-1) ^ (i - i0)).x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) *
x ^ (2 * i0) * y ^ (2 * (i - i0)) *
((-1) ^ i0 * (-1) ^ (i - i0)) =
(-1) ^ i0 * / INR (fact (2 * i0)) * x ^ (2 * i0) *
(-1) ^ (i - i0) * / INR (fact (2 * (i - i0))) *
y ^ (2 * (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(-1) ^ i0 * (-1) ^ (i - i0) = (-1) ^ i
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
ring.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(-1) ^ i0 * (-1) ^ (i - i0) = (-1) ^ i
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
pattern i at 2; replace i with (i0 + (i - i0))%nat.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(-1) ^ i0 * (-1) ^ (i - i0) = (-1) ^ (i0 + (i - i0))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite pow_add.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(-1) ^ i0 * (-1) ^ (i - i0) =
(-1) ^ i0 * (-1) ^ (i - i0)
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
ring.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(i0 + (i - i0))%nat = i
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
symmetry ; apply le_plus_minus; assumption.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * C (2 * i) (2 * i0)
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold C.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) *
(INR (fact (2 * i)) /
 (INR (fact (2 * i0)) * INR (fact (2 * i - 2 * i0))))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv; repeat rewrite <- Rmult_assoc.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i)) * INR (fact (2 * i)) *
/ (INR (fact (2 * i0)) * INR (fact (2 * i - 2 * i0)))
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite <- Rinv_l_sym.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
1 *
/ (INR (fact (2 * i0)) * INR (fact (2 * i - 2 * i0)))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rmult_1_l.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ (INR (fact (2 * i0)) * INR (fact (2 * i - 2 * i0)))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
rewrite Rinv_mult_distr.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i0)) * / INR (fact (2 * i - 2 * i0))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i - 2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
replace (2 * i - 2 * i0)%nat with (2 * (i - i0))%nat.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0))) =
/ INR (fact (2 * i0)) * / INR (fact (2 * (i - i0)))
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(2 * (i - i0))%nat = (2 * i - 2 * i0)%nat
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i - 2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
reflexivity.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
(2 * (i - i0))%nat = (2 * i - 2 * i0)%nat
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i - 2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
omega.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i - 2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i - 2 * i0)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= S n)%nat
i0:nat
H1:(i0 <= i)%nat
INR (fact (2 * i)) <> 0
x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply INR_fact_neq_0.x, y:R
n:nat
H:(0 < n)%nat
Reste2 x y n =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) /
      INR (fact (2 * S (l + k) + 1)) *
      x ^ (2 * S (l + k) + 1) *
      ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
       y ^ (2 * (n - l) + 1))) 
     (Init.Nat.pred (n - k))) 
  (Init.Nat.pred n)
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Reste2; apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= Init.Nat.pred n)%nat
sum_f_R0
  (fun l : nat =>
   (-1) ^ S (l + i) / INR (fact (2 * S (l + i) + 1)) *
   x ^ (2 * S (l + i) + 1) *
   ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1))) *
   y ^ (2 * (n - l) + 1)) 
  (Init.Nat.pred (n - i)) =
sum_f_R0
  (fun l : nat =>
   (-1) ^ S (l + i) / INR (fact (2 * S (l + i) + 1)) *
   x ^ (2 * S (l + i) + 1) *
   ((-1) ^ (n - l) / INR (fact (2 * (n - l) + 1)) *
    y ^ (2 * (n - l) + 1))) 
  (Init.Nat.pred (n - i))
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= Init.Nat.pred n)%nat
i0:nat
H1:(i0 <= Init.Nat.pred (n - i))%nat
(-1) ^ S (i0 + i) / INR (fact (2 * S (i0 + i) + 1)) *
x ^ (2 * S (i0 + i) + 1) *
((-1) ^ (n - i0) / INR (fact (2 * (n - i0) + 1))) *
y ^ (2 * (n - i0) + 1) =
(-1) ^ S (i0 + i) / INR (fact (2 * S (i0 + i) + 1)) *
x ^ (2 * S (i0 + i) + 1) *
((-1) ^ (n - i0) / INR (fact (2 * (n - i0) + 1)) *
 y ^ (2 * (n - i0) + 1))
x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv; ring.x, y:R
n:nat
H:(0 < n)%nat
Reste1 x y (S n) =
sum_f_R0
  (fun k : nat =>
   sum_f_R0
     (fun l : nat =>
      (-1) ^ S (l + k) / INR (fact (2 * S (l + k))) *
      x ^ (2 * S (l + k)) *
      ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
       y ^ (2 * (S n - l)))) 
     (Init.Nat.pred (S n - k))) 
  (Init.Nat.pred (S n))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Reste1; apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= Init.Nat.pred (S n))%nat
sum_f_R0
  (fun l : nat =>
   (-1) ^ S (l + i) / INR (fact (2 * S (l + i))) *
   x ^ (2 * S (l + i)) *
   ((-1) ^ (S n - l) / INR (fact (2 * (S n - l)))) *
   y ^ (2 * (S n - l))) 
  (Init.Nat.pred (S n - i)) =
sum_f_R0
  (fun l : nat =>
   (-1) ^ S (l + i) / INR (fact (2 * S (l + i))) *
   x ^ (2 * S (l + i)) *
   ((-1) ^ (S n - l) / INR (fact (2 * (S n - l))) *
    y ^ (2 * (S n - l)))) 
  (Init.Nat.pred (S n - i))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply sum_eq; intros.x, y:R
n:nat
H:(0 < n)%nat
i:nat
H0:(i <= Init.Nat.pred (S n))%nat
i0:nat
H1:(i0 <= Init.Nat.pred (S n - i))%nat
(-1) ^ S (i0 + i) / INR (fact (2 * S (i0 + i))) *
x ^ (2 * S (i0 + i)) *
((-1) ^ (S n - i0) / INR (fact (2 * (S n - i0)))) *
y ^ (2 * (S n - i0)) =
(-1) ^ S (i0 + i) / INR (fact (2 * S (i0 + i))) *
x ^ (2 * S (i0 + i)) *
((-1) ^ (S n - i0) / INR (fact (2 * (S n - i0))) *
 y ^ (2 * (S n - i0)))
x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
unfold Rdiv; ring.x, y:R
n:nat
H:(0 < n)%nat
(0 < S n)%nat
apply lt_O_Sn.
Qed.

Lemma pow_sqr : forall (x:R) (i:nat), x ^ (2 * i) = (x * x) ^ i.forall (x : R) (i : nat), x ^ (2 * i) = (x * x) ^ i
Proof.forall (x : R) (i : nat), x ^ (2 * i) = (x * x) ^ i
intros.x:R
i:nat
x ^ (2 * i) = (x * x) ^ i
assert (H := pow_Rsqr x i).x:R
i:nat
H:x ^ (2 * i) = x² ^ i
x ^ (2 * i) = (x * x) ^ i
unfold Rsqr in H; exact H.
Qed.

Lemma A1_cvg : forall x:R, Un_cv (A1 x) (cos x).forall x : R, Un_cv (A1 x) (cos x)
Proof.forall x : R, Un_cv (A1 x) (cos x)
intro.x:R
Un_cv (A1 x) (cos x)
unfold cos; destruct (exist_cos (Rsqr x)) as (x0,p).x, x0:R
p:cos_in x² x0
Un_cv (A1 x) x0
unfold cos_in, cos_n, infinite_sum, R_dist in p.x, x0:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n -
     x0) < eps
Un_cv (A1 x) x0
unfold Un_cv, R_dist; intros.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n -
     x0) < eps0
eps:R
H:eps > 0
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (A1 x n - x0) < eps
destruct (p eps H) as (x1,H0).x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n : nat,
(n >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n -
   x0) < eps
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (A1 x n - x0) < eps
exists x1; intros.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs (A1 x n - x0) < eps
unfold A1.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun k : nat =>
      (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) n -
   x0) < eps
replace
 (sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) n) with
 (sum_f_R0 (fun i:nat => (-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i) n).x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i) n -
   x0) < eps
x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) n
apply H0; assumption.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * x ^ (2 * k)) n
apply sum_eq.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
     x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) * x² ^ i) n0 -
   x0) < eps
n:nat
H1:(n >= x1)%nat
forall i : nat,
(i <= n)%nat ->
(-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i =
(-1) ^ i / INR (fact (2 * i)) * x ^ (2 * i)
intros.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
       n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
     n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i)) * (x * x) ^ i =
(-1) ^ i / INR (fact (2 * i)) * x ^ (2 * i)
replace ((x * x) ^ i) with (x ^ (2 * i)).x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
       n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
     n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i)) * x ^ (2 * i) =
(-1) ^ i / INR (fact (2 * i)) * x ^ (2 * i)
x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
       n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
     n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
x ^ (2 * i) = (x * x) ^ i
reflexivity.x, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
       n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) * x² ^ i0)
     n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
x ^ (2 * i) = (x * x) ^ i
apply pow_sqr.
Qed.

Lemma C1_cvg : forall x y:R, Un_cv (C1 x y) (cos (x + y)).forall x y : R, Un_cv (C1 x y) (cos (x + y))
Proof.forall x y : R, Un_cv (C1 x y) (cos (x + y))
intros.x, y:R
Un_cv (C1 x y) (cos (x + y))
unfold cos.x, y:R
Un_cv (C1 x y) (let (a, _) := exist_cos (x + y)² in a)
destruct (exist_cos (Rsqr (x + y))) as (x0,p).x, y, x0:R
p:cos_in (x + y)² x0
Un_cv (C1 x y) x0
unfold cos_in, cos_n, infinite_sum, R_dist in p.x, y, x0:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n - x0) < eps
Un_cv (C1 x y) x0
unfold Un_cv, R_dist; intros.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n - x0) < eps0
eps:R
H:eps > 0
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (C1 x y n - x0) < eps
destruct (p eps H) as (x1,H0).x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n : nat,
(n >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n - x0) < eps
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (C1 x y n - x0) < eps
exists x1; intros.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs (C1 x y n - x0) < eps
unfold C1.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun k : nat =>
      (-1) ^ k / INR (fact (2 * k)) *
      (x + y) ^ (2 * k)) n - x0) < eps
replace
 (sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k)) * (x + y) ^ (2 * k)) n)
 with
 (sum_f_R0
    (fun i:nat => (-1) ^ i / INR (fact (2 * i)) * ((x + y) * (x + y)) ^ i) n).x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      ((x + y) * (x + y)) ^ i) n - x0) < eps
x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i)) *
   ((x + y) * (x + y)) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * (x + y) ^ (2 * k))
  n
apply H0; assumption.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i)) *
   ((x + y) * (x + y)) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k)) * (x + y) ^ (2 * k))
  n
apply sum_eq.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i)) *
        (x + y)² ^ i) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i)) *
      (x + y)² ^ i) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
forall i : nat,
(i <= n)%nat ->
(-1) ^ i / INR (fact (2 * i)) *
((x + y) * (x + y)) ^ i =
(-1) ^ i / INR (fact (2 * i)) * (x + y) ^ (2 * i)
intros.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) *
        (x + y)² ^ i0) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) *
      (x + y)² ^ i0) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i)) *
((x + y) * (x + y)) ^ i =
(-1) ^ i / INR (fact (2 * i)) * (x + y) ^ (2 * i)
replace (((x + y) * (x + y)) ^ i) with ((x + y) ^ (2 * i)).x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) *
        (x + y)² ^ i0) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) *
      (x + y)² ^ i0) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i)) * (x + y) ^ (2 * i) =
(-1) ^ i / INR (fact (2 * i)) * (x + y) ^ (2 * i)
x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) *
        (x + y)² ^ i0) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) *
      (x + y)² ^ i0) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(x + y) ^ (2 * i) = ((x + y) * (x + y)) ^ i
reflexivity.x, y, x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0)) *
        (x + y)² ^ i0) n0 - x0) < eps0
eps:R
H:eps > 0
x1:nat
H0:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0)) *
      (x + y)² ^ i0) n0 - x0) < eps
n:nat
H1:(n >= x1)%nat
i:nat
H2:(i <= n)%nat
(x + y) ^ (2 * i) = ((x + y) * (x + y)) ^ i
apply pow_sqr.
Qed.

Lemma B1_cvg : forall x:R, Un_cv (B1 x) (sin x).forall x : R, Un_cv (B1 x) (sin x)
Proof.forall x : R, Un_cv (B1 x) (sin x)
intro.x:R
Un_cv (B1 x) (sin x)
case (Req_dec x 0); intro.x:R
H:x = 0
Un_cv (B1 x) (sin x)
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
rewrite H.x:R
H:x = 0
Un_cv (B1 0) (sin 0)
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
rewrite sin_0.x:R
H:x = 0
Un_cv (B1 0) 0
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
unfold B1.x:R
H:x = 0
Un_cv
  (fun N : nat =>
   sum_f_R0
     (fun k : nat =>
      (-1) ^ k / INR (fact (2 * k + 1)) *
      0 ^ (2 * k + 1)) N) 0
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
unfold Un_cv; unfold R_dist; intros; exists 0%nat; intros.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(n >= 0)%nat
Rabs
  (sum_f_R0
     (fun k : nat =>
      (-1) ^ k / INR (fact (2 * k + 1)) *
      0 ^ (2 * k + 1)) n - 0) < eps
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
replace
 (sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
    n) with 0.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(n >= 0)%nat
Rabs (0 - 0) < eps
x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(n >= 0)%nat
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
  n
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
unfold Rminus; rewrite Rplus_opp_r; rewrite Rabs_R0; assumption.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(n >= 0)%nat
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
  n
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
induction  n as [| n Hrecn].x:R
H:x = 0
eps:R
H0:eps > 0
H1:(0 >= 0)%nat
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
  0
x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(S n >= 0)%nat
Hrecn:(n >= 0)%nat ->
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) *
   0 ^ (2 * k + 1)) n
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
  (S n)
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
simpl; ring.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(S n >= 0)%nat
Hrecn:(n >= 0)%nat ->
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) *
   0 ^ (2 * k + 1)) n
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * 0 ^ (2 * k + 1))
  (S n)
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
rewrite tech5; rewrite <- Hrecn.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(S n >= 0)%nat
Hrecn:(n >= 0)%nat ->
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) *
   0 ^ (2 * k + 1)) n
0 =
0 +
(-1) ^ S n / INR (fact (2 * S n + 1)) *
0 ^ (2 * S n + 1)
x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(S n >= 0)%nat
Hrecn:(n >= 0)%nat ->
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) *
   0 ^ (2 * k + 1)) n
(n >= 0)%nat
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
simpl; ring.x:R
H:x = 0
eps:R
H0:eps > 0
n:nat
H1:(S n >= 0)%nat
Hrecn:(n >= 0)%nat ->
0 =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) *
   0 ^ (2 * k + 1)) n
(n >= 0)%nat
x:R
H:x <> 0
Un_cv (B1 x) (sin x)
unfold ge; apply le_O_n.x:R
H:x <> 0
Un_cv (B1 x) (sin x)
unfold sin.x:R
H:x <> 0
Un_cv (B1 x) (let (a, _) := exist_sin x² in x * a) destruct (exist_sin (Rsqr x)) as (x0,p).x:R
H:x <> 0
x0:R
p:sin_in x² x0
Un_cv (B1 x) (x * x0)
unfold sin_in, sin_n, infinite_sum, R_dist in p.x:R
H:x <> 0
x0:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n - x0) < eps
Un_cv (B1 x) (x * x0)
unfold Un_cv, R_dist; intros.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n - x0) < eps0
eps:R
H0:eps > 0
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (B1 x n - x * x0) < eps
cut (0 < eps / Rabs x);
 [ intro
 | unfold Rdiv; apply Rmult_lt_0_compat;
    [ assumption | apply Rinv_0_lt_compat; apply Rabs_pos_lt; assumption ] ].x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (B1 x n - x * x0) < eps
destruct (p (eps / Rabs x) H1) as (x1,H2).x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n : nat,
(n >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n - x0) < eps / Rabs x
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (B1 x n - x * x0) < eps
exists x1; intros.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs (B1 x n - x * x0) < eps
unfold B1.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun k : nat =>
      (-1) ^ k / INR (fact (2 * k + 1)) *
      x ^ (2 * k + 1)) n - 
   x * x0) < eps
replace
 (sum_f_R0 (fun k:nat => (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
    n) with
 (x *
  sum_f_R0 (fun i:nat => (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n).x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs
  (x *
   sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
     n - x * x0) < eps
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
replace
 (x *
  sum_f_R0 (fun i:nat => (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n -
  x * x0) with
 (x *
  (sum_f_R0 (fun i:nat => (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n -
   x0)); [ idtac | ring ].x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs
  (x *
   (sum_f_R0
      (fun i : nat =>
       (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
      n - x0)) < eps
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
rewrite Rabs_mult.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs x *
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
     n - x0) < eps
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
apply Rmult_lt_reg_l with (/ Rabs x).x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
0 < / Rabs x
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
/ Rabs x *
(Rabs x *
 Rabs
   (sum_f_R0
      (fun i : nat =>
       (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
      n - x0)) < / Rabs x * eps
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
apply Rinv_0_lt_compat; apply Rabs_pos_lt; assumption.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
/ Rabs x *
(Rabs x *
 Rabs
   (sum_f_R0
      (fun i : nat =>
       (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
      n - x0)) < / Rabs x * eps
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
rewrite <- Rmult_assoc, <- Rinv_l_sym, Rmult_1_l, <- (Rmult_comm eps).x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i)
     n - x0) < eps * / Rabs x
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs x <> 0
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n apply H2;
 assumption.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
Rabs x <> 0
x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
apply Rabs_no_R0; assumption.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
x *
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i) n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
rewrite scal_sum.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
sum_f_R0
  (fun i : nat =>
   (-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i * x)
  n =
sum_f_R0
  (fun k : nat =>
   (-1) ^ k / INR (fact (2 * k + 1)) * x ^ (2 * k + 1))
  n
apply sum_eq.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i : nat =>
        (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
       n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i : nat =>
      (-1) ^ i / INR (fact (2 * i + 1)) * x² ^ i)
     n0 - x0) < eps / Rabs x
n:nat
H3:(n >= x1)%nat
forall i : nat,
(i <= n)%nat ->
(-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i * x =
(-1) ^ i / INR (fact (2 * i + 1)) * x ^ (2 * i + 1)
intros.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
        x² ^ i0) n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
      x² ^ i0) n0 - x0) < 
eps / Rabs x
n:nat
H3:(n >= x1)%nat
i:nat
H4:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i * x =
(-1) ^ i / INR (fact (2 * i + 1)) * x ^ (2 * i + 1)
rewrite pow_add.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
        x² ^ i0) n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
      x² ^ i0) n0 - x0) < 
eps / Rabs x
n:nat
H3:(n >= x1)%nat
i:nat
H4:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i * x =
(-1) ^ i / INR (fact (2 * i + 1)) *
(x ^ (2 * i) * x ^ 1)
rewrite pow_sqr.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
        x² ^ i0) n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
      x² ^ i0) n0 - x0) < 
eps / Rabs x
n:nat
H3:(n >= x1)%nat
i:nat
H4:(i <= n)%nat
(-1) ^ i / INR (fact (2 * i + 1)) * (x * x) ^ i * x =
(-1) ^ i / INR (fact (2 * i + 1)) *
((x * x) ^ i * x ^ 1)
simpl.x:R
H:x <> 0
x0:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat ->
  Rabs
    (sum_f_R0
       (fun i0 : nat =>
        (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
        x² ^ i0) n0 - x0) < eps0
eps:R
H0:eps > 0
H1:0 < eps / Rabs x
x1:nat
H2:forall n0 : nat,
(n0 >= x1)%nat ->
Rabs
  (sum_f_R0
     (fun i0 : nat =>
      (-1) ^ i0 / INR (fact (2 * i0 + 1)) *
      x² ^ i0) n0 - x0) < 
eps / Rabs x
n:nat
H3:(n >= x1)%nat
i:nat
H4:(i <= n)%nat
(-1) ^ i / INR (fact (i + (i + 0) + 1)) * (x * x) ^ i *
x =
(-1) ^ i / INR (fact (i + (i + 0) + 1)) *
((x * x) ^ i * (x * 1))
ring.
Qed.