code: def create_simple_tear_sheet(
      returns,
      positions=None,
      transactions=None,
      benchmark_rets=None,
      slippage=None,
      estimate_intraday="infer",
      live_start_date=None,
      turnover_denom="AGB",
      header_rows=None,
  ):
      """
      Simpler version of create_full_tear_sheet; generates summary performance
      statistics and important plots as a single image.
  
      - Plots: cumulative returns, rolling beta, rolling Sharpe, underwater,
          exposure, top 10 holdings, total holdings, long/short holdings,
          daily turnover, transaction time distribution.
      - Never accept market_data input (market_data = None)
      - Never accept sector_mappings input (sector_mappings = None)
      - Never perform bootstrap analysis (bootstrap = False)
      - Never hide posistions on top 10 holdings plot (hide_positions = False)
      - Always use default cone_std (cone_std = (1.0, 1.5, 2.0))
  
      Parameters
      ----------
      returns : pd.Series
          Daily returns of the strategy, noncumulative.
           - Time series with decimal returns.
           - Example:
              2015-07-16    -0.012143
              2015-07-17    0.045350
              2015-07-20    0.030957
              2015-07-21    0.004902
      positions : pd.DataFrame, optional
          Daily net position values.
           - Time series of dollar amount invested in each position and cash.
           - Days where stocks are not held can be represented by 0 or NaN.
           - Non-working capital is labelled 'cash'
           - Example:
              index         'AAPL'         'MSFT'          cash
              2004-01-09    13939.3800     -14012.9930     711.5585
              2004-01-12    14492.6300     -14624.8700     27.1821
              2004-01-13    -13853.2800    13653.6400      -43.6375
      transactions : pd.DataFrame, optional
          Executed trade volumes and fill prices.
          - One row per trade.
          - Trades on different names that occur at the
            same time will have identical indicies.
          - Example:
              index                  amount   price    symbol
              2004-01-09 12:18:01    483      324.12   'AAPL'
              2004-01-09 12:18:01    122      83.10    'MSFT'
              2004-01-13 14:12:23    -75      340.43   'AAPL'
      benchmark_rets : pd.Series, optional
          Daily returns of the benchmark, noncumulative.
      slippage : int/float, optional
          Basis points of slippage to apply to returns before generating
          tearsheet stats and plots.
          If a value is provided, slippage parameter sweep
          plots will be generated from the unadjusted returns.
          Transactions and positions must also be passed.
          - See txn.adjust_returns_for_slippage for more details.
      live_start_date : datetime, optional
          The point in time when the strategy began live trading,
          after its backtest period. This datetime should be normalized.
      turnover_denom : str, optional
          Either AGB or portfolio_value, default AGB.
          - See full explanation in txn.get_turnover.
      header_rows : dict or OrderedDict, optional
          Extra rows to display at the top of the perf stats table.
      set_context : boolean, optional
          If True, set default plotting style context.
      """
  
      positions = utils.check_intraday(
          estimate_intraday, returns, positions, transactions
      )
  
      if (slippage is not None) and (transactions is not None):
          returns = txn.adjust_returns_for_slippage(
              returns, positions, transactions, slippage
          )
  
      always_sections = 4
      positions_sections = 4 if positions is not None else 0
      transactions_sections = 2 if transactions is not None else 0
      live_sections = 1 if live_start_date is not None else 0
      benchmark_sections = 1 if benchmark_rets is not None else 0
  
      vertical_sections = sum(
          [
              always_sections,
              positions_sections,
              transactions_sections,
              live_sections,
              benchmark_sections,
          ]
      )
  
      if live_start_date is not None:
          live_start_date = ep.utils.get_utc_timestamp(live_start_date)
  
      plotting.show_perf_stats(
          returns,
          benchmark_rets,
          positions=positions,
          transactions=transactions,
          turnover_denom=turnover_denom,
          live_start_date=live_start_date,
          header_rows=header_rows,
      )
  
      fig = plt.figure(figsize=(14, vertical_sections * 6))
      gs = gridspec.GridSpec(
          vertical_sections, 3, wspace=0.5, hspace=0.5
      )
  
      ax_rolling_returns = plt.subplot(gs[:2, :])
      i = 2
      if benchmark_rets is not None:
          ax_rolling_beta = plt.subplot(
              gs[i, :], sharex=ax_rolling_returns
          )
          i += 1
      ax_rolling_sharpe = plt.subplot(
          gs[i, :], sharex=ax_rolling_returns
      )
      i += 1
      ax_underwater = plt.subplot(gs[i, :], sharex=ax_rolling_returns)
      i += 1
  
      plotting.plot_rolling_returns(
          returns,
          factor_returns=benchmark_rets,
          live_start_date=live_start_date,
          cone_std=(1.0, 1.5, 2.0),
          ax=ax_rolling_returns,
      )
      ax_rolling_returns.set_title("Cumulative returns")
  
      if benchmark_rets is not None:
          plotting.plot_rolling_beta(
              returns, benchmark_rets, ax=ax_rolling_beta
          )
  
      plotting.plot_rolling_sharpe(returns, ax=ax_rolling_sharpe)
  
      plotting.plot_drawdown_underwater(returns, ax=ax_underwater)
  
      if positions is not None:
          # Plot simple positions tear sheet
          ax_exposures = plt.subplot(gs[i, :])
          i += 1
          ax_top_positions = plt.subplot(gs[i, :], sharex=ax_exposures)
          i += 1
          ax_holdings = plt.subplot(gs[i, :], sharex=ax_exposures)
          i += 1
          ax_long_short_holdings = plt.subplot(gs[i, :])
          i += 1
  
          positions_alloc = pos.get_percent_alloc(positions)
  
          plotting.plot_exposures(returns, positions, ax=ax_exposures)
  
          plotting.show_and_plot_top_positions(
              returns,
              positions_alloc,
              show_and_plot=0,
              hide_positions=False,
              ax=ax_top_positions,
          )
  
          plotting.plot_holdings(
              returns, positions_alloc, ax=ax_holdings
          )
  
          plotting.plot_long_short_holdings(
              returns, positions_alloc, ax=ax_long_short_holdings
          )
  
          if transactions is not None:
              # Plot simple transactions tear sheet
              ax_turnover = plt.subplot(gs[i, :])
              i += 1
              ax_txn_timings = plt.subplot(gs[i, :])
              i += 1
  
              plotting.plot_turnover(
                  returns,
                  transactions,
                  positions,
                  turnover_denom=turnover_denom,
                  ax=ax_turnover,
              )
  
              plotting.plot_txn_time_hist(
                  transactions, ax=ax_txn_timings
              )
  
      for ax in fig.axes:
          plt.setp(ax.get_xticklabels(), visible=True)
  
imports: from __future__ import division
  import warnings
  from time import time
  import empyrical
  from IPython.display import display, Markdown
  import matplotlib.gridspec
  import matplotlib.pyplot
  import pandas
  from .None import _seaborn
  from .None import capacity
  from .None import perf_attrib
  from .None import plotting
  from .None import pos
  from .None import round_trips
  from .None import timeseries
  from .None import txn
  from .None import utils
label_desc: Use image node_id 3 for calling a global function with example usage: create_simple_tear_sheet(returns, positions, transactions, benchmark_rets, slippage, estimate_intraday, live_start_date, turnover_denom, header_rows) without return types