class_docstr: Constructs a multivariate normal random variable, based on mean and covariance.
  Can be multivariate, or a batch of multivariate normals
  
  Passing a vector mean corresponds to a multivariate normal.
  Passing a matrix mean corresponds to a batch of multivariate normals.
  
  :param mean: `... x N` mean of mvn distribution.
  :param covariance_matrix: `... x N X N` covariance matrix of mvn distribution.
  :param validate_args: If True, validate `mean` anad `covariance_matrix` arguments. (Default: False.)
  
  :ivar torch.Size base_sample_shape: The shape of a base sample (without
      batching) that is used to generate a single sample.
  :ivar torch.Tensor covariance_matrix: The covariance matrix, represented as a dense :class:`torch.Tensor`
  :ivar ~linear_operator.LinearOperator lazy_covariance_matrix: The covariance matrix, represented
      as a :class:`~linear_operator.LinearOperator`.
  :ivar torch.Tensor mean: The mean.
  :ivar torch.Tensor stddev: The standard deviation.
  :ivar torch.Tensor variance: The variance.
docstr: See :py:meth:`torch.distributions.Distribution.log_prob
  <torch.distributions.distribution.Distribution.log_prob>`.
docstr_tok: ["See",":","py",":","meth",":","`","torch.distributions.Distribution.log_prob","<","torch.distributions.distribution.Distribution.log_prob",">","`","."]
code: def log_prob(self, value: Tensor) -> Tensor:
      r"""
      See :py:meth:`torch.distributions.Distribution.log_prob
      <torch.distributions.distribution.Distribution.log_prob>`.
      """
      if settings.fast_computations.log_prob.off():
          return super().log_prob(value)
  
      if self._validate_args:
          self._validate_sample(value)
  
      mean, covar = self.loc, self.lazy_covariance_matrix
      diff = value - mean
  
      # Repeat the covar to match the batch shape of diff
      if diff.shape[:-1] != covar.batch_shape:
          if len(diff.shape[:-1]) < len(covar.batch_shape):
              diff = diff.expand(covar.shape[:-1])
          else:
              padded_batch_shape = (
                  *(1 for _ in range(diff.dim() + 1 - covar.dim())),
                  *covar.batch_shape,
              )
              covar = covar.repeat(
                  *(
                      diff_size // covar_size
                      for diff_size, covar_size in zip(
                          diff.shape[:-1], padded_batch_shape
                      )
                  ),
                  1,
                  1,
              )
  
      # Get log determininant and first part of quadratic form
      covar = covar.evaluate_kernel()
      inv_quad, logdet = covar.inv_quad_logdet(
          inv_quad_rhs=diff.unsqueeze(-1), logdet=True
      )
  
      res = -0.5 * sum(
          [inv_quad, logdet, diff.size(-1) * math.log(2 * math.pi)]
      )
      return res
  
imports: from __future__ import annotations
  import math
  import warnings
  from numbers import Number
  from typing import Optional, Tuple, Union
  import torch
  from linear_operator import to_dense, to_linear_operator
  from linear_operator.operators import DiagLinearOperator, LinearOperator, RootLinearOperator
  from torch import Tensor
  from torch.distributions import MultivariateNormal
  from torch.distributions.kl import register_kl
  from torch.distributions.utils import _standard_normal, lazy_property
  from ..None import settings
  from ..utils.warnings import NumericalWarning
  from .distribution import Distribution
label_desc: Use image node_id 13 for calling the MultivariateNormal obj's underlying member method code with example usage: obj.log_prob(value) and returns: res, super