<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
"http://www.w3.org/TR/MathML2/dtd/xhtml-math11-f.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:mml="http://www.w3.org/1998/Math/MathML">
<head>
<!-- The next lines of text are copied from the file htmlout.cfg, and can be modified there -->
<style type="text/css">
ol { list-style-type: decimal}
ol >li >  ol { list-style-type: lower-alpha}
ol >li > ol > li > ol { list-style-type: lower-roman}
.displayed {text-align: center}
.displayed { display: block !
important}
span.leadin {float: left}
span.vspace {vertical-align: top}
span.rule {display: inline; background-color: black}
span.inline-math-graphics {white-space: nowrap}
hr.pagebreak {color: green}
table {border-collapse: collapse; border-color: black}
table td {border-color: black}
.inlineTable {display: inline}
math {color:red}
</style>
<!-- End of lines from htmlout.cfg -->

<meta name="COMMENTS" content=" Pour des DS  format de la page numerotation  bas de page:\input{tcilatex}\input{tcilatex}"/>
<meta name="CREATED" content="Friday, May 06, 2011 17:19:27"/>
<meta name="REVISED" content="Friday, May 06, 2011 21:56:16"/>
<meta name="GENERATOR" content="Scientific Word"/>
<title>EDHEC_2011_E.xml</title>
</head>
<body >
<p class="center">
   <span class="huge2">EDHEC eco 2011</span>
</p>
<h1 class="section">Exercice 1</h1>
<p>
   On consid&#xe8;re la fonction
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>f</mml:mi>
     </mml:mrow>
   </mml:math>
   d&#xe9;finie sur
   <mml:math display="inline">
     <mml:mrow>
       <mml:msup>
         <mml:mi fontstyle="upright">&Ropf;</mml:mi>
         <mml:mo>+</mml:mo>
       </mml:msup>
     </mml:mrow>
   </mml:math>
   par :
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mi>f</mml:mi>
         <mml:mo>&ApplyFunction;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
           <mml:mi>x</mml:mi>
           <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mo form="infix">=</mml:mo>
       <mml:mrow>
         <mml:mrow>
           <mml:mstyle displaystyle="true" scriptlevel="0">
             <mml:mfrac>
               <mml:mn>2</mml:mn>
               <mml:msup>
                 <mml:mi>x</mml:mi>
                 <mml:mn>2</mml:mn>
               </mml:msup>
             </mml:mfrac>
           </mml:mstyle>
         </mml:mrow>
         <mml:mo>&InvisibleTimes;</mml:mo>
         <mml:mrow>
           <mml:msubsup>
             <mml:mo form="prefix" largeop="true">&int;</mml:mo>
             <mml:mn>0</mml:mn>
             <mml:mi>x</mml:mi>
           </mml:msubsup>
           <mml:mrow>
             <mml:mrow>
               <mml:mstyle displaystyle="true" scriptlevel="0">
                 <mml:mfrac>
                   <mml:mi>t</mml:mi>
                   <mml:mrow>
                     <mml:msup>
                       <mml:mi>e</mml:mi>
                       <mml:mi>t</mml:mi>
                     </mml:msup>
                     <mml:mo form="infix">+</mml:mo>
                     <mml:mn>1</mml:mn>
                   </mml:mrow>
                 </mml:mfrac>
               </mml:mstyle>
             </mml:mrow>
             <mml:mo>&InvisibleTimes;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix">&dd;</mml:mo>
               <mml:mi>t</mml:mi>
             </mml:mrow>
           </mml:mrow>
         </mml:mrow>
       </mml:mrow>
     </mml:mrow>
   </mml:math>
   si
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>x</mml:mi>
       <mml:mo form="infix">></mml:mo>
       <mml:mn>0</mml:mn>
     </mml:mrow>
   </mml:math>
   et
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:mi>f</mml:mi>
           <mml:mo>&ApplyFunction;</mml:mo>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
             <mml:mn>0</mml:mn>
             <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
           </mml:mrow>
         </mml:mrow>
         <mml:mo form="infix">=</mml:mo>
         <mml:mrow>
           <mml:mstyle displaystyle="true" scriptlevel="0">
             <mml:mfrac>
               <mml:mn>1</mml:mn>
               <mml:mn>2</mml:mn>
             </mml:mfrac>
           </mml:mstyle>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
</p>
<ol>
   <li>
      <ol>
         <li>
            <p>
            Montrer que :
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix">&ForAll;</mml:mo>
         <mml:mrow>
           <mml:mi>x</mml:mi>
           <mml:mo form="infix">&Element;</mml:mo>
           <mml:mo form="postfix" fence="true" stretchy="false">]</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mrow>
         <mml:mn>0</mml:mn>
         <mml:mo form="infix">,</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix">+</mml:mo>
           <mml:mi>&infin;</mml:mi>
         </mml:mrow>
       </mml:mrow>
       <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix">&ForAll;</mml:mo>
         <mml:mrow>
           <mml:mi>t</mml:mi>
           <mml:mo form="infix">&Element;</mml:mo>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
             <mml:mrow>
               <mml:mn>0</mml:mn>
               <mml:mo form="infix">,</mml:mo>
               <mml:mi>x</mml:mi>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
           </mml:mrow>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:mstyle displaystyle="true" scriptlevel="0">
             <mml:mfrac>
               <mml:mn>1</mml:mn>
               <mml:mrow>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mi>x</mml:mi>
                 </mml:msup>
                 <mml:mo form="infix">+</mml:mo>
                 <mml:mn>1</mml:mn>
               </mml:mrow>
             </mml:mfrac>
           </mml:mstyle>
         </mml:mrow>
         <mml:mo form="infix">&le;</mml:mo>
         <mml:mrow>
           <mml:mstyle displaystyle="true" scriptlevel="0">
             <mml:mfrac>
               <mml:mn>1</mml:mn>
               <mml:mrow>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mi>t</mml:mi>
                 </mml:msup>
                 <mml:mo form="infix">+</mml:mo>
                 <mml:mn>1</mml:mn>
               </mml:mrow>
             </mml:mfrac>
           </mml:mstyle>
         </mml:mrow>
         <mml:mo form="infix">&le;</mml:mo>
         <mml:mrow>
           <mml:mstyle displaystyle="true" scriptlevel="0">
             <mml:mfrac>
               <mml:mn>1</mml:mn>
               <mml:mn>2</mml:mn>
             </mml:mfrac>
           </mml:mstyle>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            Etablir alors que, pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
           </mml:mrow>
         </mml:math>
            strictement positif, on a :
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mrow>
                 <mml:mstyle displaystyle="true" scriptlevel="0">
                   <mml:mfrac>
                     <mml:mn>1</mml:mn>
                     <mml:mrow>
                       <mml:msup>
                         <mml:mi>e</mml:mi>
                         <mml:mi>x</mml:mi>
                       </mml:msup>
                       <mml:mo form="infix">+</mml:mo>
                       <mml:mn>1</mml:mn>
                     </mml:mrow>
                   </mml:mfrac>
                 </mml:mstyle>
               </mml:mrow>
               <mml:mo form="infix">&le;</mml:mo>
               <mml:mrow>
                 <mml:mi>f</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="infix">&le;</mml:mo>
               <mml:mrow>
                 <mml:mstyle displaystyle="true" scriptlevel="0">
                   <mml:mfrac>
                     <mml:mn>1</mml:mn>
                     <mml:mn>2</mml:mn>
                   </mml:mfrac>
                 </mml:mstyle>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire que la fonction
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            est continue (&#xe0; droite) en 0.
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            Montrer que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            est de classe
            <mml:math display="inline">
           <mml:mrow>
             <mml:msup>
               <mml:mi>C</mml:mi>
               <mml:mn>1</mml:mn>
             </mml:msup>
           </mml:mrow>
         </mml:math>
            sur
            <mml:math display="inline">
           <mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="false">]</mml:mo>
             <mml:mrow>
               <mml:mn>0</mml:mn>
               <mml:mo form="infix">,</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix">+</mml:mo>
                 <mml:mi>&infin;</mml:mi>
               </mml:mrow>
             </mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            puis v&#xe9;rifier que, pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
           </mml:mrow>
         </mml:math>
            strictement positif, on peut &#xe9;crire :
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mrow>
                 <mml:msup>
                   <mml:mi>f</mml:mi>
                   <mml:mo form="postfix">&prime;</mml:mo>
                 </mml:msup>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="infix">=</mml:mo>
               <mml:mrow>
                 <mml:mrow>
                   <mml:mo form="prefix">&minus;</mml:mo>
                   <mml:mrow>
                     <mml:mstyle displaystyle="true" scriptlevel="0">
                       <mml:mfrac>
                         <mml:mn>4</mml:mn>
                         <mml:msup>
                           <mml:mi>x</mml:mi>
                           <mml:mn>3</mml:mn>
                         </mml:msup>
                       </mml:mfrac>
                     </mml:mstyle>
                   </mml:mrow>
                 </mml:mrow>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:mrow>
                   <mml:mi>g</mml:mi>
                   <mml:mo>&ApplyFunction;</mml:mo>
                   <mml:mrow>
                     <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                     <mml:mi>x</mml:mi>
                     <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                   </mml:mrow>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            o&#xf9;
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>g</mml:mi>
           </mml:mrow>
         </mml:math>
            est une fonction que l'on d&#xe9;terminera.
         </p>
      </li>
      <li>
         <p>
            Etudier les variations, puis le signe de la fonction
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>g</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
            En d&#xe9;duire que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            est d&#xe9;croissante sur
            <mml:math display="inline">
           <mml:mrow>
             <mml:msup>
               <mml:mi fontstyle="upright">&Ropf;</mml:mi>
               <mml:mo>+</mml:mo>
             </mml:msup>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            Montrer que, pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>t</mml:mi>
           </mml:mrow>
         </mml:math>
            positif, on a :
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mstyle displaystyle="true" scriptlevel="0">
                 <mml:mfrac>
                   <mml:mi>t</mml:mi>
                   <mml:mrow>
                     <mml:msup>
                       <mml:mi>e</mml:mi>
                       <mml:mi>t</mml:mi>
                     </mml:msup>
                     <mml:mo form="infix">+</mml:mo>
                     <mml:mn>1</mml:mn>
                   </mml:mrow>
                 </mml:mfrac>
               </mml:mstyle>
             </mml:mrow>
             <mml:mo form="infix">&le;</mml:mo>
             <mml:mn>1.</mml:mn>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire la limite de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:mi>x</mml:mi>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            lorsque
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
           </mml:mrow>
         </mml:math>
            tend vers
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix">+</mml:mo>
               <mml:mi>&infin;</mml:mi>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
</li>
</ol>
</li>
</ol>

<h1 class="section">Exercice 2</h1>
<p>
   On d&#xe9;signe par
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>E</mml:mi>
     </mml:mrow>
   </mml:math>
   l'espace vectoriel des fonctions polyn&#xf4;miales de degr&#xe9;
   inf&#xe9;rieur ou &#xe9;gal &#xe0; 2 et on note
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi fontstyle="upright">&Bscr;</mml:mi>
     </mml:mrow>
   </mml:math>
   la base
   <mml:math display="inline">
     <mml:mrow>
       <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
       <mml:mrow>
         <mml:msub>
           <mml:mi>e</mml:mi>
           <mml:mn>0</mml:mn>
         </mml:msub>
         <mml:mo form="infix">,</mml:mo>
         <mml:msub>
           <mml:mi>e</mml:mi>
           <mml:mn>1</mml:mn>
         </mml:msub>
         <mml:mo form="infix">,</mml:mo>
         <mml:msub>
           <mml:mi>e</mml:mi>
           <mml:mn>2</mml:mn>
         </mml:msub>
       </mml:mrow>
       <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
     </mml:mrow>
   </mml:math>
   de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>E</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   o&#xf9; pour tout r&#xe9;el
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>x</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   on a :
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:msub>
             <mml:mi>e</mml:mi>
             <mml:mn>0</mml:mn>
           </mml:msub>
           <mml:mo>&ApplyFunction;</mml:mo>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
             <mml:mi>x</mml:mi>
             <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
           </mml:mrow>
         </mml:mrow>
         <mml:mo form="infix">=</mml:mo>
         <mml:mn>1</mml:mn>
       </mml:mrow>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:msub>
           <mml:mi>e</mml:mi>
           <mml:mn>1</mml:mn>
         </mml:msub>
         <mml:mo>&ApplyFunction;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
           <mml:mi>x</mml:mi>
           <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mo form="infix">=</mml:mo>
       <mml:mi>x</mml:mi>
     </mml:mrow>
   </mml:math>
   et
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:msub>
             <mml:mi>e</mml:mi>
             <mml:mn>2</mml:mn>
           </mml:msub>
           <mml:mo>&ApplyFunction;</mml:mo>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
             <mml:mi>x</mml:mi>
             <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
           </mml:mrow>
         </mml:mrow>
         <mml:mo form="infix">=</mml:mo>
         <mml:msup>
           <mml:mi>x</mml:mi>
           <mml:mn>2</mml:mn>
         </mml:msup>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math><br/>On
   consid&#xe8;re l'application, not&#xe9;e
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>f</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   qui &#xe0; toute fonction polyn&#xf4;miale
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>P</mml:mi>
     </mml:mrow>
   </mml:math>
   appartenant &#xe0;
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>E</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   associe la fonction polyn&#xf4;miale
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>f</mml:mi>
       <mml:mo>&ApplyFunction;</mml:mo>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
         <mml:mi>P</mml:mi>
         <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
       </mml:mrow>
     </mml:mrow>
   </mml:math>
   d&#xe9;finie par :
   <mml:math mode="display" display="block">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:mo form="prefix">&ForAll;</mml:mo>
           <mml:mrow>
             <mml:mi>x</mml:mi>
             <mml:mo form="infix">&Element;</mml:mo>
             <mml:mi fontstyle="upright">&Ropf;</mml:mi>
           </mml:mrow>
         </mml:mrow>
         <mml:mo form="infix">,</mml:mo>
         <mml:mspace width="thickmathspace" />
         <mml:mrow>
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
               <mml:mrow>
                 <mml:mi>f</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                   <mml:mi>P</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
             </mml:mrow>
             <mml:mo>&InvisibleTimes;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
               <mml:mi>x</mml:mi>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:mrow>
             <mml:mrow>
               <mml:mn>2</mml:mn>
               <mml:mo>&InvisibleTimes;</mml:mo>
               <mml:mi>x</mml:mi>
               <mml:mo>&InvisibleTimes;</mml:mo>
               <mml:mrow>
                 <mml:mi>P</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
             <mml:mo form="infix">&minus;</mml:mo>
             <mml:mrow>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                 <mml:mrow>
                   <mml:msup>
                     <mml:mi>x</mml:mi>
                     <mml:mn>2</mml:mn>
                   </mml:msup>
                   <mml:mo form="infix">&minus;</mml:mo>
                   <mml:mn>1</mml:mn>
                 </mml:mrow>
                 <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
               </mml:mrow>
               <mml:mo>&InvisibleTimes;</mml:mo>
               <mml:mrow>
                 <mml:msup>
                   <mml:mi>P</mml:mi>
                   <mml:mo form="postfix">&prime;</mml:mo>
                 </mml:msup>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
           </mml:mrow>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
</p>
<ol>
   <li>
      <ol>
         <li>
            <p>
            Montrer que
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>f</mml:mi>
     </mml:mrow>
   </mml:math>
            est une application lin&#xe9;aire.
         </p>
      </li>
      <li>
         <p>
            En &#xe9;crivant, pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mrow>
                 <mml:mi>P</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="infix">=</mml:mo>
               <mml:mrow>
                 <mml:mi>a</mml:mi>
                 <mml:mo form="infix">+</mml:mo>
                 <mml:mrow>
                   <mml:mi>b</mml:mi>
                   <mml:mo>&InvisibleTimes;</mml:mo>
                   <mml:mi>x</mml:mi>
                 </mml:mrow>
                 <mml:mo form="infix">+</mml:mo>
                 <mml:mrow>
                   <mml:mi>c</mml:mi>
                   <mml:mo>&InvisibleTimes;</mml:mo>
                   <mml:msup>
                     <mml:mi>x</mml:mi>
                     <mml:mn>2</mml:mn>
                   </mml:msup>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            d&#xe9;finir explicitement
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:mrow>
                 <mml:mi>f</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                   <mml:mi>P</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
             <mml:mo>&InvisibleTimes;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:mi>x</mml:mi>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            puis en d&#xe9;duire que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            est un endomorphisme de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>E</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            Ecrire
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mi>f</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:msub>
                   <mml:mi>e</mml:mi>
                   <mml:mn>0</mml:mn>
                 </mml:msub>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:msub>
                 <mml:mi>e</mml:mi>
                 <mml:mn>1</mml:mn>
               </mml:msub>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:msub>
                 <mml:mi>e</mml:mi>
                 <mml:mn>2</mml:mn>
               </mml:msub>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            comme des combinaisons lin&#xe9;aires de
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>e</mml:mi>
               <mml:mn>0</mml:mn>
             </mml:msub>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>e</mml:mi>
               <mml:mn>1</mml:mn>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>e</mml:mi>
               <mml:mn>2</mml:mn>
             </mml:msub>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            puis en d&#xe9;duire la matrice
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>A</mml:mi>
           </mml:mrow>
         </mml:math>
            de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            dans la base
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi fontstyle="upright">&Bscr;</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            V&#xe9;rifier que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo mathcolor="gray" form="prefix">Im</mml:mo>
               <mml:mi>f</mml:mi>
             </mml:mrow>
             <mml:mo form="infix">=</mml:mo>
             <mml:mrow>
               <mml:mi mathcolor="gray">vect</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                 <mml:mrow>
                   <mml:msub>
                     <mml:mi>e</mml:mi>
                     <mml:mn>1</mml:mn>
                   </mml:msub>
                   <mml:mo form="infix">,</mml:mo>
                   <mml:mrow>
                     <mml:msub>
                       <mml:mi>e</mml:mi>
                       <mml:mn>0</mml:mn>
                     </mml:msub>
                     <mml:mo form="infix">+</mml:mo>
                     <mml:msub>
                       <mml:mi>e</mml:mi>
                       <mml:mn>2</mml:mn>
                     </mml:msub>
                   </mml:mrow>
                 </mml:mrow>
                 <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et donner la dimension de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi mathcolor="gray">Im</mml:mi>
             <mml:mi>f</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            D&#xe9;terminer
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi mathcolor="gray">Ker</mml:mi>
             <mml:mi>f</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            A l'aide de la m&#xe9;thode du pivot de Gauss, d&#xe9;terminer les valeurs
            propres de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>A</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
           </mml:mrow>
         </mml:math>
            est diagonalisable et donner les sous-espaces propres de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            V&#xe9;rifier que les sous-espaces propres de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>f</mml:mi>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            autres que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo mathcolor="gray" form="prefix">Ker</mml:mo>
               <mml:mi>f</mml:mi>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            sont inclus dans
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi mathcolor="gray">Im</mml:mi>
             <mml:mi>f</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
</li>
</ol>
</li>
</ol>

<h1 class="section">Exercice 3</h1>
<p>
   On d&#xe9;signe par
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   un entier naturel sup&#xe9;rieur ou &#xe9;gal &#xe0; 2. On dispose de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   urnes, num&#xe9;rot&#xe9;es de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mn>1</mml:mn>
     </mml:mrow>
   </mml:math>
   &#xe0;
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   contenant chacune
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   boules. On r&#xe9;p&#xe8;te
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   &#xe9;preuves, chacune consistant &#xe0; choisir une urne au hasard et &#xe0;
   en extraire une urne au hasard. On suppose que les choix des urnes sont
   ind&#xe9;pendants les uns des autres.<br/>Pour tout
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>i</mml:mi>
     </mml:mrow>
   </mml:math>
   de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">{</mml:mo>
         <mml:mrow>
           <mml:mn>1</mml:mn>
           <mml:mo form="infix">,</mml:mo>
           <mml:mn>2</mml:mn>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>&hellip;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>n</mml:mi>
         </mml:mrow>
         <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">}</mml:mo>
       </mml:mrow>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   on note
   <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>X</mml:mi>
         <mml:mi>i</mml:mi>
       </mml:msub>
     </mml:mrow>
   </mml:math>
   la variable al&#xe9;atoire prenant la valeur 1 si l'urne num&#xe9;rot&#xe9;e
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>i</mml:mi>
     </mml:mrow>
   </mml:math>
   contient toujours
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   boules au bout de ces
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>n</mml:mi>
     </mml:mrow>
   </mml:math>
   &#xe9;preuves, et qui prend la valeur 0 sinon.
</p>
<ol>
   <li>
      <ol>
         <li>
            <p>
            Pour tout
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>i</mml:mi>
     </mml:mrow>
   </mml:math>
            et tout
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>k</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            &#xe9;l&#xe9;ments de
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="false">{</mml:mo>
         <mml:mrow>
           <mml:mn>1</mml:mn>
           <mml:mo form="infix">,</mml:mo>
           <mml:mn>2</mml:mn>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>&hellip;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>n</mml:mi>
         </mml:mrow>
         <mml:mo form="postfix" fence="true" stretchy="false">}</mml:mo>
       </mml:mrow>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            on note
            <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>U</mml:mi>
         <mml:mrow>
           <mml:mi>i</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>k</mml:mi>
         </mml:mrow>
       </mml:msub>
     </mml:mrow>
   </mml:math>
            l'&#xe9;v&#xe9;nement "l'urne num&#xe9;ro
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>i</mml:mi>
     </mml:mrow>
   </mml:math>
            est choisie &#xe0; la
            <mml:math display="inline">
     <mml:mrow>
       <mml:msup>
         <mml:mi>k</mml:mi>
         <mml:mtext mathcolor="black">&#xe8;me</mml:mtext>
       </mml:msup>
     </mml:mrow>
   </mml:math>
            &#xe9;preuve".<br/>Ecrire l'&#xe9;v&#xe9;nement
            <mml:math display="inline">
     <mml:mrow>
       <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
       <mml:mrow>
         <mml:msub>
           <mml:mi>X</mml:mi>
           <mml:mi>i</mml:mi>
         </mml:msub>
         <mml:mo form="infix">=</mml:mo>
         <mml:mn>1</mml:mn>
       </mml:mrow>
       <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
     </mml:mrow>
   </mml:math>
            &#xe0; l'aide de certains des &#xe9;v&#xe9;nements
            <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>U</mml:mi>
         <mml:mrow>
           <mml:mi>i</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>k</mml:mi>
         </mml:mrow>
       </mml:msub>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            puis montrer que :
            <mml:math mode="display" display="block">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:mrow>
             <mml:mo form="prefix">&ForAll;</mml:mo>
             <mml:mrow>
               <mml:mi>i</mml:mi>
               <mml:mo form="infix">&Element;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">{</mml:mo>
                 <mml:mrow>
                   <mml:mn>1</mml:mn>
                   <mml:mo form="infix">,</mml:mo>
                   <mml:mn>2</mml:mn>
                   <mml:mo form="infix">,</mml:mo>
                   <mml:mi>&hellip;</mml:mi>
                   <mml:mo form="infix">,</mml:mo>
                   <mml:mi>n</mml:mi>
                 </mml:mrow>
                 <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">}</mml:mo>
               </mml:mrow>
             </mml:mrow>
           </mml:mrow>
           <mml:mo form="infix">,</mml:mo>
           <mml:mspace width="thickmathspace" />
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
             <mml:mrow>
               <mml:msub>
                 <mml:mi>X</mml:mi>
                 <mml:mi>i</mml:mi>
               </mml:msub>
               <mml:mo form="infix">=</mml:mo>
               <mml:mn>1</mml:mn>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:msup>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
               <mml:mrow>
                 <mml:mn>1</mml:mn>
                 <mml:mo form="infix">&minus;</mml:mo>
                 <mml:mrow>
                   <mml:mstyle displaystyle="true" scriptlevel="0">
                     <mml:mfrac>
                       <mml:mn>1</mml:mn>
                       <mml:mi>n</mml:mi>
                     </mml:mfrac>
                   </mml:mstyle>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
             </mml:mrow>
             <mml:mi>n</mml:mi>
           </mml:msup>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            Justifier &#xe9;galement que, si
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>i</mml:mi>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>j</mml:mi>
           </mml:mrow>
         </mml:math>
            sont deux entiers distincts, &#xe9;l&#xe9;ments de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">{</mml:mo>
               <mml:mrow>
                 <mml:mn>1</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mn>2</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>&hellip;</mml:mi>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>n</mml:mi>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="false">}</mml:mo>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            on a :
            <mml:math mode="display" display="block">
           <mml:mrow>
             <mml:mrow>
               <mml:mrow>
                 <mml:mi>P</mml:mi>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                   <mml:mrow>
                     <mml:mrow>
                       <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                       <mml:mrow>
                         <mml:msub>
                           <mml:mi>X</mml:mi>
                           <mml:mi>i</mml:mi>
                         </mml:msub>
                         <mml:mo form="infix">=</mml:mo>
                         <mml:mn>1</mml:mn>
                       </mml:mrow>
                       <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                     </mml:mrow>
                     <mml:mo form="infix">&cap;</mml:mo>
                     <mml:mrow>
                       <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                       <mml:mrow>
                         <mml:msub>
                           <mml:mi>X</mml:mi>
                           <mml:mi>j</mml:mi>
                         </mml:msub>
                         <mml:mo form="infix">=</mml:mo>
                         <mml:mn>1</mml:mn>
                       </mml:mrow>
                       <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                     </mml:mrow>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="infix">=</mml:mo>
               <mml:msup>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                   <mml:mrow>
                     <mml:mn>1</mml:mn>
                     <mml:mo form="infix">&minus;</mml:mo>
                     <mml:mrow>
                       <mml:mstyle displaystyle="true" scriptlevel="0">
                         <mml:mfrac>
                           <mml:mn>2</mml:mn>
                           <mml:mi>n</mml:mi>
                         </mml:mfrac>
                       </mml:mstyle>
                     </mml:mrow>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                 </mml:mrow>
                 <mml:mi>n</mml:mi>
               </mml:msup>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            Comparer
            <mml:math display="inline">
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
             <mml:mrow>
               <mml:mn>1</mml:mn>
               <mml:mo form="infix">&minus;</mml:mo>
               <mml:mrow>
                 <mml:mstyle displaystyle="true" scriptlevel="0">
                   <mml:mfrac>
                     <mml:mn>2</mml:mn>
                     <mml:mi>n</mml:mi>
                   </mml:mfrac>
                 </mml:mstyle>
               </mml:mrow>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:msup>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                 <mml:mrow>
                   <mml:mn>1</mml:mn>
                   <mml:mo form="infix">&minus;</mml:mo>
                   <mml:mrow>
                     <mml:mstyle displaystyle="true" scriptlevel="0">
                       <mml:mfrac>
                         <mml:mn>1</mml:mn>
                         <mml:mi>n</mml:mi>
                       </mml:mfrac>
                     </mml:mstyle>
                   </mml:mrow>
                 </mml:mrow>
                 <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
               </mml:mrow>
               <mml:mn>2</mml:mn>
             </mml:msup>
           </mml:mrow>
         </mml:math>
            et en d&#xe9;duire que, si
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>i</mml:mi>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>j</mml:mi>
           </mml:mrow>
         </mml:math>
            sont deux entiers distincts, &#xe9;l&#xe9;ments de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">{</mml:mo>
               <mml:mrow>
                 <mml:mn>1</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mn>2</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>&hellip;</mml:mi>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>n</mml:mi>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">}</mml:mo>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            alors les variables
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>X</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>X</mml:mi>
               <mml:mi>j</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            en sont pas ind&#xe9;pendantes.
         </p>
      </li>
   </ol>
</li>
<li>
   <p>
      On pose
      <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:msub>
                 <mml:mi>Y</mml:mi>
                 <mml:mi>n</mml:mi>
               </mml:msub>
               <mml:mo form="infix">=</mml:mo>
               <mml:mrow>
                 <mml:munderover>
                   <mml:mo form="prefix" movablelimits="true" largeop="true">&sum;</mml:mo>
                   <mml:mrow>
                     <mml:mi>k</mml:mi>
                     <mml:mo form="infix">=</mml:mo>
                     <mml:mn>1</mml:mn>
                   </mml:mrow>
                   <mml:mi>n</mml:mi>
                 </mml:munderover>
                 <mml:msub>
                   <mml:mi>X</mml:mi>
                   <mml:mi>i</mml:mi>
                 </mml:msub>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
   </p>
   <ol>
      <li>
         <p>
            D&#xe9;terminer l'esp&#xe9;rance de
            <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>Y</mml:mi>
         <mml:mi>n</mml:mi>
       </mml:msub>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
            not&#xe9;e
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mi>E</mml:mi>
         <mml:mo>&ApplyFunction;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
           <mml:msub>
             <mml:mi>Y</mml:mi>
             <mml:mi>n</mml:mi>
           </mml:msub>
           <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire
            <mml:math display="inline">
           <mml:mrow>
             <mml:munder>
               <mml:mo mathcolor="gray" form="prefix" movablelimits="true">lim</mml:mo>
               <mml:mrow>
                 <mml:mi>n</mml:mi>
                 <mml:mo form="infix">&rarr;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix">+</mml:mo>
                   <mml:mi>&infin;</mml:mi>
                 </mml:mrow>
               </mml:mrow>
             </mml:munder>
             <mml:mrow>
               <mml:mstyle displaystyle="true" scriptlevel="0">
                 <mml:mfrac>
                   <mml:mrow>
                     <mml:mi>E</mml:mi>
                     <mml:mo>&ApplyFunction;</mml:mo>
                     <mml:mrow>
                       <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                       <mml:msub>
                         <mml:mi>Y</mml:mi>
                         <mml:mi>n</mml:mi>
                       </mml:msub>
                       <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                     </mml:mrow>
                   </mml:mrow>
                   <mml:mi>n</mml:mi>
                 </mml:mfrac>
               </mml:mstyle>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et donner un &#xe9;quivalent de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>E</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:msub>
                 <mml:mi>Y</mml:mi>
                 <mml:mi>n</mml:mi>
               </mml:msub>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            lorsque
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>n</mml:mi>
           </mml:mrow>
         </mml:math>
            est au voisinage de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix">+</mml:mo>
               <mml:mi>&infin;</mml:mi>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <p>
      Pour tout
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>i</mml:mi>
           </mml:mrow>
         </mml:math>
      de
      <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">{</mml:mo>
               <mml:mrow>
                 <mml:mn>1</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mn>2</mml:mn>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>&hellip;</mml:mi>
                 <mml:mo form="infix">,</mml:mo>
                 <mml:mi>n</mml:mi>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">}</mml:mo>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
      on note
      <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>N</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
      la variable al&#xe9;atoire &#xe9;gale au nombre de boules manquantes dans
      l'urne num&#xe9;rot&#xe9;e
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>i</mml:mi>
           </mml:mrow>
         </mml:math>
      &#xe0; la fin de ces
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>n</mml:mi>
           </mml:mrow>
         </mml:math>
      &#xe9;preuves.
   </p>
   <ol>
      <li>
         <p>
            Donner sans calcul la loi de
            <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>N</mml:mi>
         <mml:mi>i</mml:mi>
       </mml:msub>
     </mml:mrow>
   </mml:math>
            ainsi que la valeur de
            <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mi>E</mml:mi>
         <mml:mo>&ApplyFunction;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
           <mml:msub>
             <mml:mi>N</mml:mi>
             <mml:mi>i</mml:mi>
           </mml:msub>
           <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            Que vaut le produit
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>N</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
             <mml:mo>&InvisibleTimes;</mml:mo>
             <mml:msub>
               <mml:mi>X</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            ?
         </p>
      </li>
      <li>
         <p>
            Les variables
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>N</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            et
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>X</mml:mi>
               <mml:mi>i</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            sont-elles ind&#xe9;pendantes ?
         </p>
      </li>
   </ol>
</li>
<li>
   <p>
      Compl&#xe9;ter le programme informatique suivant pour qu'il simule
      l'exp&#xe9;rience d&#xe9;crite au d&#xe9;but de cet exercice et affiche les
      valeurs prises par
      <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>X</mml:mi>
               <mml:mn>1</mml:mn>
             </mml:msub>
           </mml:mrow>
         </mml:math>
      et
      <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>N</mml:mi>
               <mml:mn>1</mml:mn>
             </mml:msub>
           </mml:mrow>
         </mml:math>
      pour une valeur de
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>n</mml:mi>
           </mml:mrow>
         </mml:math>
      entr&#xe9;e par l'utilisateur.
   </p>
   <p>
      <code class="tt">Program edhec_2011;</code>
   </p>
   <p>
      <code class="tt">Var x1, n1, n, k, tirage, hasard : integer;</code>
   </p>
   <p>
      <code class="tt">Begin</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>Randomize;</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>Writeln('donnez un entier naturel n sup&#xe9;rieur ou &#xe9;gal &#xe0; 2');</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>Readln(n);</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>n1:=0; x1:=1;</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>For k:=1 to n do</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>begin</code>
   </p>
   <p>
      <code class="tt"><span style="width:2cm"><span style="padding-left:2cm"></span></span>hasard := random(n)+1;</code>
   </p>
   <p>
      <code class="tt"><span style="width:2cm"><span style="padding-left:2cm"></span></span>if hasard = 1 then begin x1 :=--------; n1:= --------; end;</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>end;</code>
   </p>
   <p>
      <code class="tt"><span style="width:1cm"><span style="padding-left:1cm"></span></span>Writeln(x1,n1);</code>
   </p>
   <p>
      <code class="tt">End.</code>
   </p>
</li>
</ol>

<h1 class="section">Probl&#xe8;me</h1>
<p>
   <strong>Notations et objectifs</strong>
</p>
<p>
   On consid&#xe8;re deux variables al&#xe9;atoires
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
   et
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Y</mml:mi>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   d&#xe9;finies sur un espace probabilis&#xe9;
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
         <mml:mrow>
           <mml:mi>&Omega;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi fontstyle="upright">&Ascr;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
       </mml:mrow>
       <mml:mtext>,</mml:mtext>
     </mml:mrow>
   </mml:math>
   et ind&#xe9;pendantes.
</p>
<p>
   On suppose que
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
   est une variable &#xe0; densit&#xe9; et on note
   <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>F</mml:mi>
         <mml:mi>X</mml:mi>
       </mml:msub>
     </mml:mrow>
   </mml:math>
   sa fonction de r&#xe9;partition.
</p>
<p>
   On suppose par ailleurs que la loi de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Y</mml:mi>
     </mml:mrow>
   </mml:math>
   est donn&#xe9;e par
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mi>P</mml:mi>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
             <mml:mrow>
               <mml:mi>Y</mml:mi>
               <mml:mo form="infix">=</mml:mo>
               <mml:mn>1</mml:mn>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
             <mml:mrow>
               <mml:mi>Y</mml:mi>
               <mml:mo form="infix">=</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix">&minus;</mml:mo>
                 <mml:mn>1</mml:mn>
               </mml:mrow>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:mrow>
             <mml:mstyle displaystyle="true" scriptlevel="0">
               <mml:mfrac>
                 <mml:mn>1</mml:mn>
                 <mml:mn>2</mml:mn>
               </mml:mfrac>
             </mml:mstyle>
           </mml:mrow>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
</p>
<p>
   L'ind&#xe9;pendance de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
   et
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Y</mml:mi>
     </mml:mrow>
   </mml:math>
   se traduit par les &#xe9;galit&#xe9;s suivantes, valables pour tout r&#xe9;el
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>x</mml:mi>
     </mml:mrow>
   </mml:math>
   :
   <mml:math mode="display" display="block">
     <mml:mrow>
       <mml:mrow>
         <mml:mrow>
           <mml:mrow>
             <mml:mi>P</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
               <mml:mrow>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                   <mml:mrow>
                     <mml:mi>X</mml:mi>
                     <mml:mo form="infix">&le;</mml:mo>
                     <mml:mi>x</mml:mi>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                 </mml:mrow>
                 <mml:mo form="infix">&cap;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                   <mml:mrow>
                     <mml:mi>Y</mml:mi>
                     <mml:mo form="infix">=</mml:mo>
                     <mml:mn>1</mml:mn>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
           <mml:mrow>
             <mml:mi>X</mml:mi>
             <mml:mo form="infix">&le;</mml:mo>
             <mml:mi>x</mml:mi>
           </mml:mrow>
           <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mrow>
         <mml:mi>P</mml:mi>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
           <mml:mrow>
             <mml:mi>Y</mml:mi>
             <mml:mo form="infix">=</mml:mo>
             <mml:mn>1</mml:mn>
           </mml:mrow>
           <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>&emsp;</mml:mtext>
       <mml:mtext mathcolor="black">et&ensp;</mml:mtext>
       <mml:mtext>&emsp;</mml:mtext>
       <mml:mrow>
         <mml:mrow>
           <mml:mrow>
             <mml:mi>P</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
               <mml:mrow>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                   <mml:mrow>
                     <mml:mi>X</mml:mi>
                     <mml:mo form="infix">&le;</mml:mo>
                     <mml:mi>x</mml:mi>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                 </mml:mrow>
                 <mml:mo form="infix">&cap;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">[</mml:mo>
                   <mml:mrow>
                     <mml:mi>Y</mml:mi>
                     <mml:mo form="infix">=</mml:mo>
                     <mml:mrow>
                       <mml:mo form="prefix">&minus;</mml:mo>
                       <mml:mn>1</mml:mn>
                     </mml:mrow>
                   </mml:mrow>
                   <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">]</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
           <mml:mo form="infix">=</mml:mo>
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
           <mml:mrow>
             <mml:mi>X</mml:mi>
             <mml:mo form="infix">&le;</mml:mo>
             <mml:mi>x</mml:mi>
           </mml:mrow>
           <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mrow>
         <mml:mi>P</mml:mi>
         <mml:mo>&InvisibleComma;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
           <mml:mrow>
             <mml:mi>Y</mml:mi>
             <mml:mo form="infix">=</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix">&minus;</mml:mo>
               <mml:mn>1</mml:mn>
             </mml:mrow>
           </mml:mrow>
           <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
   On pose
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
       <mml:mo form="infix">=</mml:mo>
       <mml:mrow>
         <mml:mi>X</mml:mi>
         <mml:mo>&InvisibleTimes;</mml:mo>
         <mml:mi>Y</mml:mi>
       </mml:mrow>
     </mml:mrow>
   </mml:math>
   et on admet que
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
     </mml:mrow>
   </mml:math>
   est, elle-aussi, une variable al&#xe9;atoire d&#xe9;finie sur
   <mml:math display="inline">
     <mml:mrow>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
         <mml:mrow>
           <mml:mi>&Omega;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi fontstyle="upright">&Ascr;</mml:mi>
           <mml:mo form="infix">,</mml:mo>
           <mml:mi>P</mml:mi>
         </mml:mrow>
         <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
       </mml:mrow>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
</p>
<p>
   On se propose d'&#xe9;tablir deux r&#xe9;sultats utiles pour la suite dans la
   partie 1, puis d'en d&#xe9;duire la loi de la variable al&#xe9;atoire
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
     </mml:mrow>
   </mml:math>
   en fonction de la loi de
   <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
   dans les parties 2 et 3.
</p>
<h2 class="subsection">Partie 1 : expression de la fonction de
r&#xe9;partition de
<mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
     </mml:mrow>
   </mml:math>
en fonction de celle de <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math></h2>
<ol>
   <li>
      <p>
         Rappeler l'expression des fonctions de r&#xe9;partition d'une variable
         al&#xe9;atoire suivant une loi uniforme sur
         <mml:math display="inline">
     <mml:mrow>
       <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
       <mml:mrow>
         <mml:mi>a</mml:mi>
         <mml:mo form="infix">,</mml:mo>
         <mml:mi>b</mml:mi>
       </mml:mrow>
       <mml:mo form="postfix" fence="true" stretchy="false">]</mml:mo>
     </mml:mrow>
   </mml:math>
         (avec
         <mml:math display="inline">
     <mml:mrow>
       <mml:mi>a</mml:mi>
       <mml:mo form="infix">&lt;</mml:mo>
       <mml:mi>b</mml:mi>
     </mml:mrow>
   </mml:math>)
         et d'une variable al&#xe9;atoire suivant une loi exponentielle de
         param&#xe8;tre
         <mml:math display="inline">
     <mml:mrow>
       <mml:mi>&lambda;</mml:mi>
     </mml:mrow>
   </mml:math>
         (avec
         <mml:math display="inline">
     <mml:mrow>
       <mml:mi>&lambda;</mml:mi>
       <mml:mo form="infix">></mml:mo>
       <mml:mn>0</mml:mn>
     </mml:mrow>
   </mml:math>).
      </p>
   </li>
   <li>
      <p>
         En utilisant le syst&#xe8;me complet d'&#xe9;v&#xe9;nements
         <mml:math display="inline">
        <mml:mrow>
          <mml:mrow>
            <mml:mo form="prefix" fence="true" stretchy="false">{</mml:mo>
            <mml:mrow>
              <mml:mrow>
                <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                <mml:mrow>
                  <mml:mi>Y</mml:mi>
                  <mml:mo form="infix">=</mml:mo>
                  <mml:mn>1</mml:mn>
                </mml:mrow>
                <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
              </mml:mrow>
              <mml:mo form="infix">,</mml:mo>
              <mml:mrow>
                <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                <mml:mrow>
                  <mml:mi>Y</mml:mi>
                  <mml:mo form="infix">=</mml:mo>
                  <mml:mrow>
                    <mml:mo form="prefix">&minus;</mml:mo>
                    <mml:mn>1</mml:mn>
                  </mml:mrow>
                </mml:mrow>
                <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
              </mml:mrow>
            </mml:mrow>
            <mml:mo form="postfix" fence="true" stretchy="false">}</mml:mo>
          </mml:mrow>
          <mml:mtext>,</mml:mtext>
        </mml:mrow>
      </mml:math>
         montrer que la fonction de r&#xe9;partition
         <mml:math display="inline">
        <mml:mrow>
          <mml:msub>
            <mml:mi>F</mml:mi>
            <mml:mi>Z</mml:mi>
          </mml:msub>
        </mml:mrow>
      </mml:math>
         de la variable al&#xe9;atoire
         <mml:math display="inline">
        <mml:mrow>
          <mml:mi>Z</mml:mi>
        </mml:mrow>
      </mml:math>
         est donn&#xe9;e par :
         <mml:math mode="display" display="block">
        <mml:mrow>
          <mml:mrow>
            <mml:mrow>
              <mml:mo form="prefix">&ForAll;</mml:mo>
              <mml:mrow>
                <mml:mi>x</mml:mi>
                <mml:mo form="infix">&Element;</mml:mo>
                <mml:mi fontstyle="upright">&Ropf;</mml:mi>
              </mml:mrow>
            </mml:mrow>
            <mml:mo form="infix">,</mml:mo>
            <mml:mspace width="thickmathspace" />
            <mml:mrow>
              <mml:mrow>
                <mml:msub>
                  <mml:mi>F</mml:mi>
                  <mml:mi>Z</mml:mi>
                </mml:msub>
                <mml:mo>&ApplyFunction;</mml:mo>
                <mml:mrow>
                  <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                  <mml:mi>x</mml:mi>
                  <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                </mml:mrow>
              </mml:mrow>
              <mml:mo form="infix">=</mml:mo>
              <mml:mrow>
                <mml:mrow>
                  <mml:mstyle displaystyle="true" scriptlevel="0">
                    <mml:mfrac>
                      <mml:mn>1</mml:mn>
                      <mml:mn>2</mml:mn>
                    </mml:mfrac>
                  </mml:mstyle>
                </mml:mrow>
                <mml:mo>&InvisibleTimes;</mml:mo>
                <mml:mrow>
                  <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">(</mml:mo>
                  <mml:mrow>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>F</mml:mi>
                        <mml:mi>X</mml:mi>
                      </mml:msub>
                      <mml:mo>&ApplyFunction;</mml:mo>
                      <mml:mrow>
                        <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                        <mml:mi>x</mml:mi>
                        <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo form="infix">&minus;</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>F</mml:mi>
                        <mml:mi>X</mml:mi>
                      </mml:msub>
                      <mml:mo>&ApplyFunction;</mml:mo>
                      <mml:mrow>
                        <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                        <mml:mrow>
                          <mml:mo form="prefix">&minus;</mml:mo>
                          <mml:mi>x</mml:mi>
                        </mml:mrow>
                        <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo form="infix">+</mml:mo>
                    <mml:mn>1</mml:mn>
                  </mml:mrow>
                  <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true">)</mml:mo>
                </mml:mrow>
              </mml:mrow>
            </mml:mrow>
          </mml:mrow>
          <mml:mtext>.</mml:mtext>
        </mml:mrow>
      </mml:math>
      </p>
</li>
</ol>

<h2 class="subsection">Partie 2 : &#xe9;tude de deux premiers exemples.</h2>
<ol>
   <li>
      <p>
         On suppose que la loi de
         <mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
         est la loi normale centr&#xe9;e r&#xe9;duite.<br/>Reconna&#xee;tre la loi de
         <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
      </p>
   </li>
   <li>
      <p>
         On suppose que la loi de
         <mml:math display="inline">
        <mml:mrow>
          <mml:mi>X</mml:mi>
        </mml:mrow>
      </mml:math>
         est la loi uniforme sur
         <mml:math display="inline">
        <mml:mrow>
          <mml:mrow>
            <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
            <mml:mrow>
              <mml:mn>0</mml:mn>
              <mml:mo form="infix">,</mml:mo>
              <mml:mn>1</mml:mn>
            </mml:mrow>
            <mml:mo form="postfix" fence="true" stretchy="false">]</mml:mo>
          </mml:mrow>
          <mml:mtext>.</mml:mtext>
        </mml:mrow>
      </mml:math>
      </p>
      <ol>
         <li>
            <p>
            D&#xe9;terminer l'expression de
            <mml:math display="inline">
        <mml:mrow>
          <mml:msub>
            <mml:mi>F</mml:mi>
            <mml:mi>X</mml:mi>
          </mml:msub>
          <mml:mo>&ApplyFunction;</mml:mo>
          <mml:mrow>
            <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
            <mml:mrow>
              <mml:mo form="prefix">&minus;</mml:mo>
              <mml:mi>x</mml:mi>
            </mml:mrow>
            <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
          </mml:mrow>
        </mml:mrow>
      </mml:math>
            selon les valeurs prises par
            <mml:math display="inline">
        <mml:mrow>
          <mml:mi>x</mml:mi>
          <mml:mtext>.</mml:mtext>
        </mml:mrow>
      </mml:math>
         </p>
      </li>
      <li>
         <p>
            D&#xe9;terminer
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>F</mml:mi>
               <mml:mi>Z</mml:mi>
             </mml:msub>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:mi>x</mml:mi>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            puis reconna&#xee;tre la loi de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
</li>
</ol>
</li>
</ol>

<h2 class="subsection">Partie 3 : &#xe9;tude du cas o&#xf9; la loi de
<mml:math display="inline">
     <mml:mrow>
       <mml:mi>X</mml:mi>
     </mml:mrow>
   </mml:math>
est la loi exponentielle de param&#xe8;tre 1.</h2>
<ol>
   <li>
      <ol>
         <li>
            <p>
            Montrer que la fonction de r&#xe9;partition
            <mml:math display="inline">
     <mml:mrow>
       <mml:msub>
         <mml:mi>F</mml:mi>
         <mml:mi>Z</mml:mi>
       </mml:msub>
     </mml:mrow>
   </mml:math>
            de la variable al&#xe9;atoire
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Z</mml:mi>
     </mml:mrow>
   </mml:math>
            est d&#xe9;finie par :
            <mml:math mode="display" display="block">
     <mml:mrow>
       <mml:mrow>
         <mml:msub>
           <mml:mi>F</mml:mi>
           <mml:mi>Z</mml:mi>
         </mml:msub>
         <mml:mo>&ApplyFunction;</mml:mo>
         <mml:mrow>
           <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
           <mml:mi>x</mml:mi>
           <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
         </mml:mrow>
       </mml:mrow>
       <mml:mo form="infix">=</mml:mo>
       <mml:mrow>
         <mml:mo form="prefix" fence="true" stretchy="true" symmetric="true">{</mml:mo>
         <mml:mtable align="axis" columnalign="center left">
           <mml:mtr>
             <mml:mtd>
               <mml:mn>1</mml:mn>
               <mml:mo form="infix">&minus;</mml:mo>
               <mml:mrow>
                 <mml:mfrac>
                   <mml:mn>1</mml:mn>
                   <mml:mn>2</mml:mn>
                 </mml:mfrac>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mrow>
                     <mml:mo form="prefix">&minus;</mml:mo>
                     <mml:mi>x</mml:mi>
                   </mml:mrow>
                 </mml:msup>
               </mml:mrow>
             </mml:mtd>
             <mml:mtd>
               <mml:mtext mathcolor="black">&ensp;si&ensp;</mml:mtext>
               <mml:mrow>
                 <mml:mi>x</mml:mi>
                 <mml:mo form="infix">&ge;</mml:mo>
                 <mml:mn>0</mml:mn>
               </mml:mrow>
             </mml:mtd>
           </mml:mtr>
           <mml:mtr>
             <mml:mtd>
               <mml:mfrac>
                 <mml:mn>1</mml:mn>
                 <mml:mn>2</mml:mn>
               </mml:mfrac>
               <mml:mo>&InvisibleTimes;</mml:mo>
               <mml:msup>
                 <mml:mi>e</mml:mi>
                 <mml:mi>x</mml:mi>
               </mml:msup>
             </mml:mtd>
             <mml:mtd>
               <mml:mtext mathcolor="black">&ensp;si&ensp;</mml:mtext>
               <mml:mrow>
                 <mml:mi>x</mml:mi>
                 <mml:mo form="infix">&lt;</mml:mo>
                 <mml:mn>0</mml:mn>
               </mml:mrow>
             </mml:mtd>
           </mml:mtr>
         </mml:mtable>
         <mml:mo form="postfix" fence="true" stretchy="true" symmetric="true"></mml:mo>
       </mml:mrow>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
           </mml:mrow>
         </mml:math>
            est une variable al&#xe9;atoire &#xe0; densit&#xe9;.
         </p>
      </li>
      <li>
         <p>
            Etablir alors qu'une densit&#xe9; de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
           </mml:mrow>
         </mml:math>
            est la fonction
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>f</mml:mi>
               <mml:mi>Z</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            d&#xe9;finie pour tout r&#xe9;el
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>x</mml:mi>
           </mml:mrow>
         </mml:math>
            par :
            <mml:math mode="display" display="block">
           <mml:mrow>
             <mml:mrow>
               <mml:mrow>
                 <mml:msub>
                   <mml:mi>f</mml:mi>
                   <mml:mi>Z</mml:mi>
                 </mml:msub>
                 <mml:mo>&ApplyFunction;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                   <mml:mi>x</mml:mi>
                   <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
                 </mml:mrow>
               </mml:mrow>
               <mml:mo form="infix">=</mml:mo>
               <mml:mrow>
                 <mml:mrow>
                   <mml:mstyle displaystyle="true" scriptlevel="0">
                     <mml:mfrac>
                       <mml:mn>1</mml:mn>
                       <mml:mn>2</mml:mn>
                     </mml:mfrac>
                   </mml:mstyle>
                 </mml:mrow>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mrow>
                     <mml:mo form="prefix">&minus;</mml:mo>
                     <mml:mrow>
                       <mml:mo form="prefix" fence="true" stretchy="false">|</mml:mo>
                       <mml:mi>x</mml:mi>
                       <mml:mo form="postfix" fence="true" stretchy="false">|</mml:mo>
                     </mml:mrow>
                   </mml:mrow>
                 </mml:msup>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            Donner la valeur de l'int&#xe9;grale
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:msubsup>
                 <mml:mo form="prefix" largeop="true">&int;</mml:mo>
                 <mml:mn>0</mml:mn>
                 <mml:mrow>
                   <mml:mo form="prefix">+</mml:mo>
                   <mml:mi>&infin;</mml:mi>
                 </mml:mrow>
               </mml:msubsup>
               <mml:mrow>
                 <mml:mi>x</mml:mi>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mrow>
                     <mml:mo form="prefix">&minus;</mml:mo>
                     <mml:mi>x</mml:mi>
                   </mml:mrow>
                 </mml:msup>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix">&dd;</mml:mo>
                   <mml:mi>x</mml:mi>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            Montrer que
            <mml:math display="inline">
           <mml:mrow>
             <mml:msub>
               <mml:mi>f</mml:mi>
               <mml:mi>Z</mml:mi>
             </mml:msub>
           </mml:mrow>
         </mml:math>
            est une fonction paire et en d&#xe9;duire l'existence et la valeur de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mi>E</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:mi>Z</mml:mi>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            Donner la valeur de l'int&#xe9;grale
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:msubsup>
                 <mml:mo form="prefix" largeop="true">&int;</mml:mo>
                 <mml:mn>0</mml:mn>
                 <mml:mrow>
                   <mml:mo form="prefix">+</mml:mo>
                   <mml:mi>&infin;</mml:mi>
                 </mml:mrow>
               </mml:msubsup>
               <mml:mrow>
                 <mml:msup>
                   <mml:mi>x</mml:mi>
                   <mml:mn>2</mml:mn>
                 </mml:msup>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:msup>
                   <mml:mi>e</mml:mi>
                   <mml:mrow>
                     <mml:mo form="prefix">&minus;</mml:mo>
                     <mml:mi>x</mml:mi>
                   </mml:mrow>
                 </mml:msup>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:mrow>
                   <mml:mo form="prefix">&dd;</mml:mo>
                   <mml:mi>x</mml:mi>
                 </mml:mrow>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            En d&#xe9;duire l'existence et la valeur de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mi>E</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:msup>
                   <mml:mi>Z</mml:mi>
                   <mml:mn>2</mml:mn>
                 </mml:msup>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            puis donner la valeur de la variance de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <ol>
      <li>
         <p>
            D&#xe9;terminer
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mi>E</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:mi>X</mml:mi>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
             <mml:mo>&InvisibleTimes;</mml:mo>
             <mml:mrow>
               <mml:mi>E</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:mi>Y</mml:mi>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et comparer avec
            <mml:math display="inline">
           <mml:mrow>
             <mml:mrow>
               <mml:mi>E</mml:mi>
               <mml:mo>&ApplyFunction;</mml:mo>
               <mml:mrow>
                 <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
                 <mml:mi>Z</mml:mi>
                 <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
               </mml:mrow>
             </mml:mrow>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
            Quel r&#xe9;sultat retrouve-t-on ainsi ?
         </p>
      </li>
      <li>
         <p>
            Exprimer
            <mml:math display="inline">
           <mml:mrow>
             <mml:msup>
               <mml:mi>Z</mml:mi>
               <mml:mn>2</mml:mn>
             </mml:msup>
           </mml:mrow>
         </mml:math>
            en fonction de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>X</mml:mi>
             <mml:mtext>,</mml:mtext>
           </mml:mrow>
         </mml:math>
            puis en d&#xe9;duire de nouveau la variance de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
   </ol>
</li>
<li>
   <p>
      Soit
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>U</mml:mi>
           </mml:mrow>
         </mml:math>
      et
      <mml:math display="inline">
           <mml:mrow>
             <mml:mi>V</mml:mi>
           </mml:mrow>
         </mml:math>
      des variables al&#xe9;atoires suivant respectivement la loi de Bernoulli de
      param&#xe8;tre
      <mml:math display="inline">
           <mml:mrow>
             <mml:mstyle displaystyle="true" scriptlevel="0">
               <mml:mfrac>
                 <mml:mn>1</mml:mn>
                 <mml:mn>2</mml:mn>
               </mml:mfrac>
             </mml:mstyle>
           </mml:mrow>
         </mml:math>
      et la loi uniforme sur
      <mml:math display="inline">
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
             <mml:mrow>
               <mml:mn>0</mml:mn>
               <mml:mo form="infix">,</mml:mo>
               <mml:mn>1</mml:mn>
             </mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">[</mml:mo>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
   </p>
   <ol>
      <li>
         <p>
            On pose
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Q</mml:mi>
       <mml:mo form="infix">=</mml:mo>
       <mml:mrow>
         <mml:mo form="prefix">&minus;</mml:mo>
         <mml:mrow>
           <mml:mi mathcolor="gray">ln</mml:mi>
           <mml:mo>&ApplyFunction;</mml:mo>
           <mml:mrow>
             <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
             <mml:mrow>
               <mml:mn>1</mml:mn>
               <mml:mo form="infix">&minus;</mml:mo>
               <mml:mi>V</mml:mi>
             </mml:mrow>
             <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
           </mml:mrow>
         </mml:mrow>
       </mml:mrow>
     </mml:mrow>
   </mml:math>
            et on admet que
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Q</mml:mi>
     </mml:mrow>
   </mml:math>
            est une variable al&#xe9;atoire. D&#xe9;terminer la fonction de
            r&#xe9;partition de
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Q</mml:mi>
     </mml:mrow>
   </mml:math>
            et en d&#xe9;duire la loi suivie par la variable al&#xe9;atoire
            <mml:math display="inline">
     <mml:mrow>
       <mml:mi>Q</mml:mi>
       <mml:mtext>.</mml:mtext>
     </mml:mrow>
   </mml:math>
         </p>
      </li>
      <li>
         <p>
            On pose
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>R</mml:mi>
             <mml:mo form="infix">=</mml:mo>
             <mml:mrow>
               <mml:mrow>
                 <mml:mn>2</mml:mn>
                 <mml:mo>&InvisibleTimes;</mml:mo>
                 <mml:mi>U</mml:mi>
               </mml:mrow>
               <mml:mo form="infix">&minus;</mml:mo>
               <mml:mn>1</mml:mn>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et on admet que
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>R</mml:mi>
           </mml:mrow>
         </mml:math>
            est une variable al&#xe9;atoire. D&#xe9;terminer
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>R</mml:mi>
             <mml:mo>&ApplyFunction;</mml:mo>
             <mml:mrow>
               <mml:mo form="prefix" fence="true" stretchy="false">(</mml:mo>
               <mml:mi>&Omega;</mml:mi>
               <mml:mo form="postfix" fence="true" stretchy="false">)</mml:mo>
             </mml:mrow>
           </mml:mrow>
         </mml:math>
            et donner la loi suivie par la variable
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>R</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p>
      </li>
      <li>
         <p>
            Informatique.
         </p>
         <p>
            En tenant compte des r&#xe9;sultats des questions 5a) et 5b), &#xe9;crire en
            <code class="tt">Turbo Pascal</code> une d&#xe9;claration de fonction dont
            l'ent&#xea;te est <code class="tt">function z:real;</code> pour qu'elle simule
            la loi de
            <mml:math display="inline">
           <mml:mrow>
             <mml:mi>Z</mml:mi>
             <mml:mtext>.</mml:mtext>
           </mml:mrow>
         </mml:math>
         </p></li></ol></li></ol>
</body>

</html>
