Ë
    óÍ:jbT  ã                   óº  — d dl mZmZmZ 	 d dlZg d¢Z G d„ d«      Z G d„ de«      Zd„ Z G d	„ d
e	e«      Z
 G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ d e«      Z G d!„ d"e«      Z G d#„ d$e«      Z G d%„ d&e«      Z G d'„ d(e«      Z G d)„ d*e«      Z G d+„ d,e«      Z G d-„ d.e«      Z G d/„ d0e«      Z G d1„ d2e«      Z G d3„ d4e«      Z G d5„ d6e«      Z  G d7„ d8e«      Z! G d9„ d:e«      Z" e«       Z#e
Z$eZ% e«       Z& e«       Z' ed «      Z( ed;«      Z)eZ* e«       Z+ e%e+d;«      Z, ed<«      Z- ed<«      Z.eZ/eZ0eZ1eZ2 ed<d=«      Z3eZ4eZ5 e«       Z6 e«       Z7 e«       Z8 e«       Z9 e«       Z: e«       Z; e«       Z< e «       Z=e!Z>e"Z?y)>é    )ÚAnyÚCallableÚOptionalN) Ú
ConstraintÚbooleanÚcatÚcorr_choleskyÚ	dependentÚdependent_propertyÚgreater_thanÚgreater_than_eqÚindependentÚinteger_intervalÚintervalÚhalf_open_intervalÚis_dependentÚ	less_thanÚlower_choleskyÚlower_triangularÚMixtureSameFamilyConstraintÚmultinomialÚnonnegativeÚnonnegative_integerÚone_hotÚpositiveÚpositive_semidefiniteÚpositive_definiteÚpositive_integerÚrealÚreal_vectorÚsimplexÚsquareÚstackÚ	symmetricÚunit_intervalc                   ó$   — e Zd ZdZdZdZd„ Zd„ Zy)r   aã  
    Abstract base class for constraints.

    A constraint object represents a region over which a variable is valid,
    e.g. within which a variable can be optimized.

    Attributes:
        is_discrete (bool): Whether constrained space is discrete.
            Defaults to False.
        event_dim (int): Number of rightmost dimensions that together define
            an event. The :meth:`check` method will remove this many dimensions
            when computing validity.
    Fr   c                 ó   — t         ‚)z“
        Returns a byte tensor of ``sample_shape + batch_shape`` indicating
        whether each event in value satisfies this constraint.
        )ÚNotImplementedError©ÚselfÚvalues     út/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/torch/distributions/constraints.pyÚcheckzConstraint.checka   s
   € ô
 "Ð!ó    c                 ó:   — | j                   j                  dd  dz   S )Né   z())Ú	__class__Ú__name__©r*   s    r,   Ú__repr__zConstraint.__repr__h   s   € Ø�~‰~×&Ñ& q rÐ*¨TÑ1Ð1r.   N)r2   Ú
__module__Ú__qualname__Ú__doc__Úis_discreteÚ	event_dimr-   r4   © r.   r,   r   r   O   s   „ ñð €KØ€Iò"ó2r.   r   c                   ój   ‡ — e Zd ZdZeedœˆ fd„
Zedefd„«       Zede	fd„«       Z
eedœd„Zd„ Zˆ xZS )	Ú
_DependentaI  
    Placeholder for variables whose support depends on other variables.
    These variables obey no simple coordinate-wise constraints.

    Args:
        is_discrete (bool): Optional value of ``.is_discrete`` in case this
            can be computed statically. If not provided, access to the
            ``.is_discrete`` attribute will raise a NotImplementedError.
        event_dim (int): Optional value of ``.event_dim`` in case this
            can be computed statically. If not provided, access to the
            ``.event_dim`` attribute will raise a NotImplementedError.
    ©r8   r9   c                ó>   •— || _         || _        t        ‰| �  «        y ©N)Ú_is_discreteÚ
_event_dimÚsuperÚ__init__)r*   r8   r9   r1   s      €r,   rC   z_Dependent.__init__z   s   ø€ Ø'ˆÔØ#ˆŒÜ‰ÑÕr.   Úreturnc                 óT   — | j                   t        u rt        d«      ‚| j                   S )Nz,.is_discrete cannot be determined statically)r@   ÚNotImplementedr(   r3   s    r,   r8   z_Dependent.is_discrete   s(   € à×Ñ¤Ñ.Ü%Ð&TÓUÐUØ× Ñ Ð r.   c                 óT   — | j                   t        u rt        d«      ‚| j                   S )Nz*.event_dim cannot be determined statically)rA   rF   r(   r3   s    r,   r9   z_Dependent.event_dim…   s$   € à�?‰?œnÑ,Ü%Ð&RÓSÐSØ�‰Ðr.   c                ól   — |t         u r| j                  }|t         u r| j                  }t        ||¬«      S )z‡
        Support for syntax to customize static attributes::

            constraints.dependent(is_discrete=True, event_dim=1)
        r=   )rF   r@   rA   r<   )r*   r8   r9   s      r,   Ú__call__z_Dependent.__call__‹   s5   € ð œ.Ñ(Ø×+Ñ+ˆKØœÑ&ØŸ™ˆIÜ k¸YÔGÐGr.   c                 ó   — t        d«      ‚)Nz1Cannot determine validity of dependent constraint)Ú
ValueError©r*   Úxs     r,   r-   z_Dependent.check—   s   € ÜÐLÓMÐMr.   )r2   r5   r6   r7   rF   rC   ÚpropertyÚboolr8   Úintr9   rI   r-   Ú__classcell__©r1   s   @r,   r<   r<   l   s]   ø„ ñð '5Àö ð
 ð!˜Tò !ó ð!ð
 ð˜3ò ó ðð
 '5Àô 
HöNr.   r<   c                 ó"   — t        | t        «      S )aÐ  
    Checks if ``constraint`` is a ``_Dependent`` object.

    Args:
        constraint : A ``Constraint`` object.

    Returns:
        ``bool``: True if ``constraint`` can be refined to the type ``_Dependent``, False otherwise.

    Examples:
        >>> import torch
        >>> from torch.distributions import Bernoulli
        >>> from torch.distributions.constraints import is_dependent

        >>> dist = Bernoulli(probs=torch.tensor([0.6], requires_grad=True))
        >>> constraint1 = dist.arg_constraints["probs"]
        >>> constraint2 = dist.arg_constraints["logits"]

        >>> for constraint in [constraint1, constraint2]:
        >>>     if is_dependent(constraint):
        >>>         continue
    )Ú
isinstancer<   )Ú
constraints    r,   r   r   ›   s   € ô. �j¤*Ó-Ð-r.   c            
       óv   ‡ — e Zd ZdZ	 deedœdeedef      dee   dee	   ddfˆ fd	„Z
dedef   dd fd
„Zˆ xZS )Ú_DependentPropertyaÚ  
    Decorator that extends @property to act like a `Dependent` constraint when
    called on a class and act like a property when called on an object.

    Example::

        class Uniform(Distribution):
            def __init__(self, low, high):
                self.low = low
                self.high = high

            @constraints.dependent_property(is_discrete=False, event_dim=0)
            def support(self):
                return constraints.interval(self.low, self.high)

    Args:
        fn (Callable): The function to be decorated.
        is_discrete (bool): Optional value of ``.is_discrete`` in case this
            can be computed statically. If not provided, access to the
            ``.is_discrete`` attribute will raise a NotImplementedError.
        event_dim (int): Optional value of ``.event_dim`` in case this
            can be computed statically. If not provided, access to the
            ``.event_dim`` attribute will raise a NotImplementedError.
    Nr=   Úfn.r8   r9   rD   c                ó@   •— t         ‰| �  |«       || _        || _        y r?   )rB   rC   r@   rA   )r*   rX   r8   r9   r1   s       €r,   rC   z_DependentProperty.__init__Ï   s!   ø€ ô 	‰Ñ˜ÔØ'ˆÔØ#ˆ�r.   c                 óF   — t        || j                  | j                  ¬«      S )z´
        Support for syntax to customize static attributes::

            @constraints.dependent_property(is_discrete=True, event_dim=1)
            def support(self): ...
        r=   )rW   r@   rA   )r*   rX   s     r,   rI   z_DependentProperty.__call__Ú   s"   € ô "Ø˜D×-Ñ-¸¿¹ô
ð 	
r.   r?   )r2   r5   r6   r7   rF   r   r   r   rO   rP   rC   rI   rQ   rR   s   @r,   rW   rW   µ   sx   ø„ ñð6 ,0ð	$ð '5Ø#1ò	$à�X˜c 3˜hÑ'Ñ(ð	$ð ˜d‘^ð		$ð
 ˜C‘=ð	$ð 
õ	$ð	
˜8 C¨ HÑ-ð 	
Ð2F÷ 	
r.   rW   c                   óZ   ‡ — e Zd ZdZˆ fd„Zedefd„«       Zedefd„«       Z	d„ Z
d„ Zˆ xZS )Ú_IndependentConstraintz»
    Wraps a constraint by aggregating over ``reinterpreted_batch_ndims``-many
    dims in :meth:`check`, so that an event is valid only if all its
    independent entries are valid.
    c                 ó”   •— t        |t        «      sJ ‚t        |t        «      sJ ‚|dk\  sJ ‚|| _        || _        t
        ‰| �  «        y ©Nr   )rT   r   rP   Úbase_constraintÚreinterpreted_batch_ndimsrB   rC   )r*   r_   r`   r1   s      €r,   rC   z_IndependentConstraint.__init__í   sM   ø€ Ü˜/¬:Ô6Ð6Ð6ÜÐ3´SÔ9Ð9Ð9Ø(¨AÒ-Ð-Ð-Ø.ˆÔØ)BˆÔ&Ü‰ÑÕr.   rD   c                 ó.   — | j                   j                  S r?   ©r_   r8   r3   s    r,   r8   z"_IndependentConstraint.is_discreteõ   ó   € à×#Ñ#×/Ñ/Ð/r.   c                 óH   — | j                   j                  | j                  z   S r?   )r_   r9   r`   r3   s    r,   r9   z _IndependentConstraint.event_dimù   s   € à×#Ñ#×-Ñ-°×0NÑ0NÑNÐNr.   c                 ó”  — | j                   j                  |«      }|j                  «       | j                  k  rB| j                   j                  | j                  z   }t        d|› d|j                  «       › �«      ‚|j                  |j                  d |j                  «       | j                  z
   dz   «      }|j                  d«      }|S )NúExpected value.dim() >= ú	 but got ©éÿÿÿÿri   )	r_   r-   Údimr`   r9   rK   ÚreshapeÚshapeÚall)r*   r+   ÚresultÚexpecteds       r,   r-   z_IndependentConstraint.checký   s´   € Ø×%Ñ%×+Ñ+¨EÓ2ˆØ�:‰:‹<˜$×8Ñ8Ò8Ø×+Ñ+×5Ñ5¸×8VÑ8VÑVˆHÜØ*¨8¨*°I¸e¿i¹i»k¸]ÐKóð ð —‘Ø�L‰LÐH˜6Ÿ:™:›<¨$×*HÑ*HÑHÐIÈEÑQó
ˆð —‘˜B“ˆØˆr.   c                 ó€   — | j                   j                  dd  › dt        | j                  «      › d| j                  › d�S )Nr0   ú(z, ú))r1   r2   Úreprr_   r`   r3   s    r,   r4   z_IndependentConstraint.__repr__
  sA   € Ø—.‘.×)Ñ)¨!¨"Ð-Ð.¨a´°T×5IÑ5IÓ0JÐ/KÈ2Èd×NlÑNlÐMmÐmnÐoÐor.   ©r2   r5   r6   r7   rC   rN   rO   r8   rP   r9   r-   r4   rQ   rR   s   @r,   r\   r\   æ   sQ   ø„ ñôð ð0˜Tò 0ó ð0ð ðO˜3ò Oó ðOòöpr.   r\   c                   óZ   ‡ — e Zd ZdZˆ fd„Zedefd„«       Zedefd„«       Z	d„ Z
d„ Zˆ xZS )r   aš  
    Constraint for the :class:`~torch.distribution.MixtureSameFamily`
    distribution that adds back the rightmost batch dimension before
    performing the validity check with the component distribution
    constraint.

    Args:
        base_constraint: The ``Constraint`` object of
            the component distribution of
            the :class:`~torch.distribution.MixtureSameFamily` distribution.
    c                 óT   •— t        |t        «      sJ ‚|| _        t        ‰| �  «        y r?   )rT   r   r_   rB   rC   )r*   r_   r1   s     €r,   rC   z$MixtureSameFamilyConstraint.__init__  s&   ø€ Ü˜/¬:Ô6Ð6Ð6Ø.ˆÔÜ‰ÑÕr.   rD   c                 ó.   — | j                   j                  S r?   rb   r3   s    r,   r8   z'MixtureSameFamilyConstraint.is_discrete   rc   r.   c                 ó.   — | j                   j                  S r?   )r_   r9   r3   s    r,   r9   z%MixtureSameFamilyConstraint.event_dim$  s   € à×#Ñ#×-Ñ-Ð-r.   c                 ó¢  — |j                  d| j                  z
  «      }| j                  j                  |«      }|j	                  «       | j                  k  r)t        d| j                  › d|j	                  «       › �«      ‚|j	                  «       | j                  z
  }|j                  |j                  d| dz   «      }|j                  d«      }|S )z˜
        Check validity of ``value`` as a possible outcome of sampling
        the :class:`~torch.distribution.MixtureSameFamily` distribution.
        ri   rf   rg   Nrh   )	Ú	unsqueezer9   r_   r-   rj   rK   rk   rl   rm   )r*   r+   Úunsqueezed_valuern   Únum_dim_to_keeps        r,   r-   z!MixtureSameFamilyConstraint.check(  s´   € ð
 !Ÿ?™?¨2°·±Ñ+>Ó?ÐØ×%Ñ%×+Ñ+Ð,<Ó=ˆØ�9‰9‹;˜Ÿ™Ò'ÜØ*¨4¯>©>Ð*:¸)ÀEÇIÁIÃKÀ=ÐQóð ð  Ÿ)™)›+¨¯©Ñ6ˆØ—‘ §¡Ð-=¨oÐ >ÀÑ FÓGˆØ—‘˜B“ˆØˆr.   c                 ó`   — | j                   j                  › dt        | j                  «      › d�S )Nrq   rr   )r1   r2   rs   r_   r3   s    r,   r4   z$MixtureSameFamilyConstraint.__repr__8  s,   € Ø—.‘.×)Ñ)Ð*¨!¬D°×1EÑ1EÓ,FÐ+GÀqÐIÐIr.   rt   rR   s   @r,   r   r     sN   ø„ ñ
ôð
 ð0˜Tò 0ó ð0ð ð.˜3ò .ó ð.òö Jr.   r   c                   ó   — e Zd ZdZdZd„ Zy)Ú_Booleanz/
    Constrain to the two values `{0, 1}`.
    Tc                 ó   — |dk(  |dk(  z  S )Nr   r0   r:   r)   s     r,   r-   z_Boolean.checkC  s   € Ø˜‘
˜u¨™zÑ*Ð*r.   N)r2   r5   r6   r7   r8   r-   r:   r.   r,   r   r   <  s   „ ñð €Kó+r.   r   c                   ó   — e Zd ZdZdZdZd„ Zy)Ú_OneHotz'
    Constrain to one-hot vectors.
    Tr0   c                 ó€   — |dk(  |dk(  z  }|j                  d«      j                  d«      }|j                  d«      |z  S )Nr   r0   ri   )ÚsumÚeqrm   )r*   r+   Ú
is_booleanÚis_normalizeds       r,   r-   z_OneHot.checkO  s@   € Ø˜q‘j U¨a¡ZÑ0ˆ
ØŸ	™	 "›×(Ñ(¨Ó+ˆØ�~‰~˜bÓ! MÑ1Ð1r.   N)r2   r5   r6   r7   r8   r9   r-   r:   r.   r,   r‚   r‚   G  s   „ ñð €KØ€Ió2r.   r‚   c                   ó2   ‡ — e Zd ZdZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_IntegerIntervalzH
    Constrain to an integer interval `[lower_bound, upper_bound]`.
    Tc                 ó>   •— || _         || _        t        ‰| �  «        y r?   ©Úlower_boundÚupper_boundrB   rC   ©r*   rŒ   r�   r1   s      €r,   rC   z_IntegerInterval.__init__\  ó   ø€ Ø&ˆÔØ&ˆÔÜ‰ÑÕr.   c                 óR   — |dz  dk(  | j                   |k  z  || j                  k  z  S ©Nr0   r   ©rŒ   r�   r)   s     r,   r-   z_IntegerInterval.checka  s2   € à�Q‰Y˜!‰^ × 0Ñ 0°EÑ 9Ñ:¸eÀt×GWÑGWÑ>WÑXð	
r.   c                 óx   — | j                   j                  dd  }|d| j                  › d| j                  › d�z  }|S ©Nr0   ú(lower_bound=z, upper_bound=rr   ©r1   r2   rŒ   r�   ©r*   Ú
fmt_strings     r,   r4   z_IntegerInterval.__repr__f  óJ   € Ø—^‘^×,Ñ,¨Q¨RÐ0ˆ
ØØ˜D×,Ñ,Ð-¨^¸D×<LÑ<LÐ;MÈQÐOñ	
ˆ
ð Ðr.   ©	r2   r5   r6   r7   r8   rC   r-   r4   rQ   rR   s   @r,   r‰   r‰   U  s   ø„ ñð €Kôò

ö
r.   r‰   c                   ó2   ‡ — e Zd ZdZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_IntegerLessThanzA
    Constrain to an integer interval `(-inf, upper_bound]`.
    Tc                 ó0   •— || _         t        ‰| �	  «        y r?   ©r�   rB   rC   ©r*   r�   r1   s     €r,   rC   z_IntegerLessThan.__init__u  ó   ø€ Ø&ˆÔÜ‰ÑÕr.   c                 ó2   — |dz  dk(  || j                   k  z  S r‘   ©r�   r)   s     r,   r-   z_IntegerLessThan.checky  ó    € Ø˜‘	˜Q‘ 5¨D×,<Ñ,<Ñ#<Ñ=Ð=r.   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S ©Nr0   z(upper_bound=rr   ©r1   r2   r�   r—   s     r,   r4   z_IntegerLessThan.__repr__|  ó8   € Ø—^‘^×,Ñ,¨Q¨RÐ0ˆ
Ø˜ d×&6Ñ&6Ð%7°qÐ9Ñ9ˆ
ØÐr.   rš   rR   s   @r,   rœ   rœ   n  ó   ø„ ñð €Kôò>ör.   rœ   c                   ó2   ‡ — e Zd ZdZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_IntegerGreaterThanz@
    Constrain to an integer interval `[lower_bound, inf)`.
    Tc                 ó0   •— || _         t        ‰| �	  «        y r?   ©rŒ   rB   rC   ©r*   rŒ   r1   s     €r,   rC   z_IntegerGreaterThan.__init__‰  r    r.   c                 ó2   — |dz  dk(  || j                   k\  z  S r‘   ©rŒ   r)   s     r,   r-   z_IntegerGreaterThan.check�  r£   r.   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S ©Nr0   r•   rr   ©r1   r2   rŒ   r—   s     r,   r4   z_IntegerGreaterThan.__repr__�  r§   r.   rš   rR   s   @r,   rª   rª   ‚  r¨   r.   rª   c                   ó   — e Zd ZdZd„ Zy)Ú_RealzF
    Trivially constrain to the extended real line `[-inf, inf]`.
    c                 ó   — ||k(  S r?   r:   r)   s     r,   r-   z_Real.check›  s   € Ø˜‰~Ðr.   N)r2   r5   r6   r7   r-   r:   r.   r,   r´   r´   –  s   „ ñór.   r´   c                   ó.   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_GreaterThanz=
    Constrain to a real half line `(lower_bound, inf]`.
    c                 ó0   •— || _         t        ‰| �	  «        y r?   r¬   r­   s     €r,   rC   z_GreaterThan.__init__¤  r    r.   c                 ó    — | j                   |k  S r?   r¯   r)   s     r,   r-   z_GreaterThan.check¨  s   € Ø×Ñ %Ñ'Ð'r.   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S r±   r²   r—   s     r,   r4   z_GreaterThan.__repr__«  r§   r.   ©r2   r5   r6   r7   rC   r-   r4   rQ   rR   s   @r,   r·   r·   Ÿ  ó   ø„ ñôò(ör.   r·   c                   ó.   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_GreaterThanEqz=
    Constrain to a real half line `[lower_bound, inf)`.
    c                 ó0   •— || _         t        ‰| �	  «        y r?   r¬   r­   s     €r,   rC   z_GreaterThanEq.__init__¶  r    r.   c                 ó    — | j                   |k  S r?   r¯   r)   s     r,   r-   z_GreaterThanEq.checkº  s   € Ø×Ñ 5Ñ(Ð(r.   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S r±   r²   r—   s     r,   r4   z_GreaterThanEq.__repr__½  r§   r.   r»   rR   s   @r,   r¾   r¾   ±  s   ø„ ñôò)ör.   r¾   c                   ó.   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú	_LessThanz>
    Constrain to a real half line `[-inf, upper_bound)`.
    c                 ó0   •— || _         t        ‰| �	  «        y r?   rž   rŸ   s     €r,   rC   z_LessThan.__init__È  r    r.   c                 ó    — || j                   k  S r?   r¢   r)   s     r,   r-   z_LessThan.checkÌ  s   € Ø�t×'Ñ'Ñ'Ð'r.   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S r¥   r¦   r—   s     r,   r4   z_LessThan.__repr__Ï  r§   r.   r»   rR   s   @r,   rÃ   rÃ   Ã  r¼   r.   rÃ   c                   ó.   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú	_IntervalzD
    Constrain to a real interval `[lower_bound, upper_bound]`.
    c                 ó>   •— || _         || _        t        ‰| �  «        y r?   r‹   rŽ   s      €r,   rC   z_Interval.__init__Ú  r�   r.   c                 ó@   — | j                   |k  || j                  k  z  S r?   r’   r)   s     r,   r-   z_Interval.checkß  s#   € Ø× Ñ  EÑ)¨e°t×7GÑ7GÑ.GÑHÐHr.   c                 óx   — | j                   j                  dd  }|d| j                  › d| j                  › d�z  }|S r”   r–   r—   s     r,   r4   z_Interval.__repr__â  r™   r.   r»   rR   s   @r,   rÈ   rÈ   Õ  s   ø„ ñôò
Iör.   rÈ   c                   ó.   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zˆ xZS )Ú_HalfOpenIntervalzD
    Constrain to a real interval `[lower_bound, upper_bound)`.
    c                 ó>   •— || _         || _        t        ‰| �  «        y r?   r‹   rŽ   s      €r,   rC   z_HalfOpenInterval.__init__ï  r�   r.   c                 ó@   — | j                   |k  || j                  k  z  S r?   r’   r)   s     r,   r-   z_HalfOpenInterval.checkô  s#   € Ø× Ñ  EÑ)¨e°d×6FÑ6FÑ.FÑGÐGr.   c                 óx   — | j                   j                  dd  }|d| j                  › d| j                  › d�z  }|S r”   r–   r—   s     r,   r4   z_HalfOpenInterval.__repr__÷  r™   r.   r»   rR   s   @r,   rÍ   rÍ   ê  s   ø„ ñôò
Hör.   rÍ   c                   ó   — e Zd ZdZdZd„ Zy)Ú_Simplexz€
    Constrain to the unit simplex in the innermost (rightmost) dimension.
    Specifically: `x >= 0` and `x.sum(-1) == 1`.
    r0   c                 ó‚   — t        j                  |dk\  d¬«      |j                  d«      dz
  j                  «       dk  z  S )Nr   ri   ©rj   r0   ç�íµ ÷Æ°>)Útorchrm   r„   Úabsr)   s     r,   r-   z_Simplex.check  s7   € Ü�y‰y˜ !™¨Ô,°·±¸2³ÀÑ1B×0GÑ0GÓ0IÈDÑ0PÑQÐQr.   N©r2   r5   r6   r7   r9   r-   r:   r.   r,   rÒ   rÒ   ÿ  s   „ ñð
 €IóRr.   rÒ   c                   ó$   — e Zd ZdZdZdZd„ Zd„ Zy)Ú_Multinomiala3  
    Constrain to nonnegative integer values summing to at most an upper bound.

    Note due to limitations of the Multinomial distribution, this currently
    checks the weaker condition ``value.sum(-1) <= upper_bound``. In the future
    this may be strengthened to ``value.sum(-1) == upper_bound``.
    Tr0   c                 ó   — || _         y r?   r¢   )r*   r�   s     r,   rC   z_Multinomial.__init__  s
   € Ø&ˆÕr.   c                 ól   — |dk\  j                  d¬«      |j                  d¬«      | j                  k  z  S )Nr   ri   rÔ   )rm   r„   r�   rL   s     r,   r-   z_Multinomial.check  s1   € Ø�Q‘�|‰| ˆ|Ó# q§u¡u° u£}¸×8HÑ8HÑ'HÑIÐIr.   N)r2   r5   r6   r7   r8   r9   rC   r-   r:   r.   r,   rÚ   rÚ     s   „ ñð €KØ€Iò'óJr.   rÚ   c                   ó   — e Zd ZdZdZd„ Zy)Ú_LowerTriangularz8
    Constrain to lower-triangular square matrices.
    é   c                 óŽ   — |j                  «       }||k(  j                  |j                  d d dz   «      j                  d«      d   S )Néþÿÿÿrh   ri   r   )ÚtrilÚviewrl   Úmin)r*   r+   Ú
value_trils      r,   r-   z_LowerTriangular.check%  sC   € Ø—Z‘Z“\ˆ
Ø˜eÑ#×)Ñ)¨%¯+©+°c°rÐ*:¸UÑ*BÓC×GÑGÈÓKÈAÑNÐNr.   NrØ   r:   r.   r,   rÞ   rÞ     s   „ ñð €IóOr.   rÞ   c                   ó   — e Zd ZdZdZd„ Zy)Ú_LowerCholeskyzP
    Constrain to lower-triangular square matrices with positive diagonals.
    rß   c                 óè   — |j                  «       }||k(  j                  |j                  d d dz   «      j                  d«      d   }|j	                  dd¬«      dkD  j                  d«      d   }||z  S )Nrá   rh   ri   r   )Údim1Údim2)râ   rã   rl   rä   Údiagonal)r*   r+   rå   r   Úpositive_diagonals        r,   r-   z_LowerCholesky.check1  s{   € Ø—Z‘Z“\ˆ
à˜5Ñ ×&Ñ& u§{¡{°3°BÐ'7¸%Ñ'?Ó@×DÑDÀRÓHÈÑKð 	ð #Ÿ^™^°¸"˜^Ó=ÀÑA×FÑFÀrÓJÈ1ÑMÐØÐ"3Ñ3Ð3r.   NrØ   r:   r.   r,   rç   rç   *  s   „ ñð €Ió4r.   rç   c                   ó   — e Zd ZdZdZd„ Zy)Ú_CorrCholeskyz}
    Constrain to lower-triangular square matrices with positive diagonals and each
    row vector being of unit length.
    rß   c                 óx  — t        j                  |j                  «      j                  |j	                  d«      z  dz  }t         j
                  j                  |j                  «       d¬«      }|dz
  j                  «       j                  |«      j                  d¬«      }t        «       j                  |«      |z  S )Nri   é
   rÔ   ç      ð?)rÖ   ÚfinfoÚdtypeÚepsÚsizeÚlinalgÚnormÚdetachr×   Úlerm   rç   r-   )r*   r+   ÚtolÚrow_normÚunit_row_norms        r,   r-   z_CorrCholesky.checkC  s”   € ä�K‰K˜Ÿ™Ó$×(Ñ(¨5¯:©:°b«>Ñ9¸BÑ>ð 	ô —<‘<×$Ñ$ U§\¡\£^¸Ð$Ó<ˆØ! C™×,Ñ,Ó.×1Ñ1°#Ó6×:Ñ:¸rÐ:ÓBˆÜÓ×%Ñ% eÓ,¨}Ñ<Ð<r.   NrØ   r:   r.   r,   rî   rî   ;  s   „ ñð
 €Ió=r.   rî   c                   ó   — e Zd ZdZdZd„ Zy)Ú_Squarez'
    Constrain to square matrices.
    rß   c                 ó¸   — t        j                  |j                  d d |j                  d   |j                  d   k(  t         j                  |j                  ¬«      S )Nrá   ri   )rõ   Ú
fill_valueró   Údevice)rÖ   Úfullrl   rO   r  r)   s     r,   r-   z_Square.checkS  sG   € Ü�z‰zØ—‘˜S˜bÐ!ØŸ™ B™¨5¯;©;°r©?Ñ:Ü—*‘*Ø—<‘<ô	
ð 	
r.   NrØ   r:   r.   r,   rþ   rþ   L  s   „ ñð €Ió
r.   rþ   c                   ó"   ‡ — e Zd ZdZˆ fd„Zˆ xZS )Ú
_Symmetricz1
    Constrain to Symmetric square matrices.
    c                 óÆ   •— t         ‰| �  |«      }|j                  «       s|S t        j                  ||j
                  d¬«      j                  d«      j                  d«      S )NrÕ   )Úatolrá   ri   )rB   r-   rm   rÖ   ÚiscloseÚmT)r*   r+   Úsquare_checkr1   s      €r,   r-   z_Symmetric.checka  sP   ø€ Ü‘w‘} UÓ+ˆØ×ÑÔ!ØÐÜ�}‰}˜U E§H¡H°4Ô8×<Ñ<¸RÓ@×DÑDÀRÓHÐHr.   ©r2   r5   r6   r7   r-   rQ   rR   s   @r,   r  r  \  s   ø„ ñ÷Ið Ir.   r  c                   ó"   ‡ — e Zd ZdZˆ fd„Zˆ xZS )Ú_PositiveSemidefinitez6
    Constrain to positive-semidefinite matrices.
    c                 óÀ   •— t         ‰| �  |«      }|j                  «       s|S t        j                  j                  |«      j                  d«      j                  d«      S )Nr   ri   )rB   r-   rm   rÖ   rö   ÚeigvalshÚge©r*   r+   Ú	sym_checkr1   s      €r,   r-   z_PositiveSemidefinite.checkm  sK   ø€ Ü‘G‘M %Ó(ˆ	Ø�}‰}ŒØÐÜ�|‰|×$Ñ$ UÓ+×.Ñ.¨qÓ1×5Ñ5°bÓ9Ð9r.   r
  rR   s   @r,   r  r  h  ó   ø„ ñ÷:ð :r.   r  c                   ó"   ‡ — e Zd ZdZˆ fd„Zˆ xZS )Ú_PositiveDefinitez2
    Constrain to positive-definite matrices.
    c                 ó¶   •— t         ‰| �  |«      }|j                  «       s|S t        j                  j                  |«      j                  j                  d«      S r^   )rB   r-   rm   rÖ   rö   Úcholesky_exÚinfor…   r  s      €r,   r-   z_PositiveDefinite.checky  sF   ø€ Ü‘G‘M %Ó(ˆ	Ø�}‰}ŒØÐÜ�|‰|×'Ñ'¨Ó.×3Ñ3×6Ñ6°qÓ9Ð9r.   r
  rR   s   @r,   r  r  t  r  r.   r  c                   óV   ‡ — e Zd ZdZdˆ fd„	Zedefd„«       Zedefd„«       Z	d„ Z
ˆ xZS )Ú_CatzÂ
    Constraint functor that applies a sequence of constraints
    `cseq` at the submatrices at dimension `dim`,
    each of size `lengths[dim]`, in a way compatible with :func:`torch.cat`.
    c                 ó(  •— t        d„ |D «       «      sJ ‚t        |«      | _        |€dgt        | j                  «      z  }t        |«      | _        t        | j                  «      t        | j                  «      k(  sJ ‚|| _        t        ‰| �  «        y )Nc              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wr?   ©rT   r   ©Ú.0Úcs     r,   ú	<genexpr>z _Cat.__init__.<locals>.<genexpr>ˆ  ó   è ø€ Ò;°”:˜a¤×,Ñ;ùó   ‚r0   )rm   ÚlistÚcseqÚlenÚlengthsrj   rB   rC   )r*   r$  rj   r&  r1   s       €r,   rC   z_Cat.__init__‡  sw   ø€ ÜÑ;°dÔ;Ô;Ð;Ð;Ü˜“JˆŒ	Øˆ?Ø�cœC §	¡	›NÑ*ˆGÜ˜G“}ˆŒÜ�4—<‘<Ó ¤C¨¯	©	£NÒ2Ð2Ð2ØˆŒÜ‰ÑÕr.   rD   c                 ó:   — t        d„ | j                  D «       «      S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr?   ©r8   r  s     r,   r   z#_Cat.is_discrete.<locals>.<genexpr>“  ó   è ø€ Ò4 Q�1—=•=Ñ4ùó   ‚©Úanyr$  r3   s    r,   r8   z_Cat.is_discrete‘  ó   € äÑ4¨$¯)©)Ô4Ó4Ð4r.   c                 ó:   — t        d„ | j                  D «       «      S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr?   ©r9   r  s     r,   r   z!_Cat.event_dim.<locals>.<genexpr>—  s   è ø€ Ò2 1�1—;•;Ñ2ùr+  )Úmaxr$  r3   s    r,   r9   z_Cat.event_dim•  s   € äÑ2¨¯	©	Ô2Ó2Ð2r.   c                 óŒ  — |j                  «        | j                   cxk  r|j                  «       k  sJ ‚ J ‚g }d}t        | j                  | j                  «      D ]G  \  }}|j	                  | j                   ||«      }|j                  |j                  |«      «       ||z   }ŒI t        j                  || j                   «      S r^   )	rj   Úzipr$  r&  ÚnarrowÚappendr-   rÖ   r   )r*   r+   ÚchecksÚstartÚconstrÚlengthÚvs          r,   r-   z
_Cat.check™  s£   € Ø—	‘	“ˆ|˜tŸx™xÔ5¨%¯)©)«+Ò5Ð5Ñ5Ð5Ð5ØˆØˆÜ! $§)¡)¨T¯\©\Ó:ò 	#‰NˆF�FØ—‘˜TŸX™X u¨fÓ5ˆAØ�M‰M˜&Ÿ,™, q›/Ô*Ø˜F‘N‰Eð	#ô �y‰y˜ §¡Ó*Ð*r.   )r   N©r2   r5   r6   r7   rC   rN   rO   r8   rP   r9   r-   rQ   rR   s   @r,   r  r  €  sH   ø„ ñõð ð5˜Tò 5ó ð5ð ð3˜3ò 3ó ð3ö+r.   r  c                   óV   ‡ — e Zd ZdZdˆ fd„	Zedefd„«       Zedefd„«       Z	d„ Z
ˆ xZS )Ú_Stackz§
    Constraint functor that applies a sequence of constraints
    `cseq` at the submatrices at dimension `dim`,
    in a way compatible with :func:`torch.stack`.
    c                 óx   •— t        d„ |D «       «      sJ ‚t        |«      | _        || _        t        ‰| �  «        y )Nc              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wr?   r  r  s     r,   r   z"_Stack.__init__.<locals>.<genexpr>¬  r!  r"  )rm   r#  r$  rj   rB   rC   )r*   r$  rj   r1   s      €r,   rC   z_Stack.__init__«  s4   ø€ ÜÑ;°dÔ;Ô;Ð;Ð;Ü˜“JˆŒ	ØˆŒÜ‰ÑÕr.   rD   c                 ó:   — t        d„ | j                  D «       «      S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr?   r)  r  s     r,   r   z%_Stack.is_discrete.<locals>.<genexpr>³  r*  r+  r,  r3   s    r,   r8   z_Stack.is_discrete±  r.  r.   c                 ól   — t        d„ | j                  D «       «      }| j                  |z   dk  r|dz  }|S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr?   r1  r  s     r,   r   z#_Stack.event_dim.<locals>.<genexpr>·  s   è ø€ Ò1 !�!—+•+Ñ1ùr+  r   r0   )r2  r$  rj   )r*   rj   s     r,   r9   z_Stack.event_dimµ  s4   € äÑ1 t§y¡yÔ1Ó1ˆØ�8‰8�c‰>˜AÒØ�1‰HˆCØˆ
r.   c           	      óÈ  — |j                  «        | j                   cxk  r|j                  «       k  sJ ‚ J ‚t        |j                  | j                   «      «      D �cg c]  }|j                  | j                   |«      ‘Œ  }}t	        j
                  t        || j                  «      D ��cg c]  \  }}|j                  |«      ‘Œ c}}| j                   «      S c c}w c c}}w r?   )	rj   Úrangerõ   ÚselectrÖ   r#   r4  r$  r-   )r*   r+   ÚiÚvsr;  r9  s         r,   r-   z_Stack.check¼  s¦   € Ø—	‘	“ˆ|˜tŸx™xÔ5¨%¯)©)«+Ò5Ð5Ñ5Ð5Ð5Ü16°u·z±zÀ$Ç(Á(Ó7KÓ1LÖM¨Aˆe�l‰l˜4Ÿ8™8 QÕ'ÐMˆÐMÜ�{‰{Ü.1°"°d·i±iÓ.@×A¡  FˆV�\‰\˜!�_ÓAÀ4Ç8Á8ó
ð 	
ùò NùãAs   Á#CÂ+C
)r   r<  rR   s   @r,   r>  r>  ¤  sH   ø„ ñõð ð5˜Tò 5ó ð5ð ð˜3ò ó ðö
r.   r>  r0   g        rñ   )@Útypingr   r   r   rÖ   Ú__all__r   r<   r   rN   rW   r\   r   r   r‚   r‰   rœ   rª   r´   r·   r¾   rÃ   rÈ   rÍ   rÒ   rÚ   rÞ   rç   rî   rþ   r  r  r  r  r>  r
   r   r   r   r   r   r   r   r   r    r   r   r   r   r   r   r%   r   r   r!   r   r   r	   r"   r$   r   r   r   r#   r:   r.   r,   ú<module>rL     sV  ð÷ +Ñ *ð óD ò!€÷H2ñ 2ô:,N�ô ,Nò^.ô4.
˜ :ô .
ôb%p˜Zô %pôP+J *ô +Jô\+ˆzô +ô2ˆjô 2ô�zô ô2�zô ô(˜*ô ô(ˆJô ô�:ô ô$�Zô ô$�
ô ô$�
ô ô*˜
ô ô*	Rˆzô 	RôJ�:ô Jô&	O�zô 	Oô4�Zô 4ô"=�Jô =ô"
ˆjô 
ô 	I�ô 	Iô	:˜Jô 	:ô	:˜
ô 	:ô!+ˆ:ô !+ôH
ˆZô 
ñB ‹L€	Ø'Ð Ø$€Ù
‹*€Ù
‹)€Ù)¨!Ó,Ð Ù& qÓ)Ð Ø#Ð Ùƒw€Ù˜$ Ó"€Ù˜Ó€Ù˜SÓ!€Ø€Ø €Ø€	Ø€Ù˜#˜sÓ#€Ø€Ø&Ð Ù
‹*€Ù#Ó%Ð ÙÓ!€Ù“€Ù	‹€Ù‹L€	Ù-Ó/Ð Ù%Ó'Ð Ø
€Ø�r.   