Ë
    f^(h‹M  ã                   ó¤  — 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! e«       Z"e
Z#eZ$ e«       Z% e«       Z& ed «      Z' ed9«      Z(eZ) e«       Z* e$e*d9«      Z+ ed:«      Z, ed:«      Z-eZ.eZ/eZ0eZ1 ed:d;«      Z2eZ3eZ4 e«       Z5 e«       Z6 e«       Z7 e«       Z8 e«       Z9 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Ú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     ú]/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/distributions/constraints.pyÚcheckzConstraint.check_   s
   € ô
 "Ð!ó    c                 ó:   — | j                   j                  dd  dz   S )Né   z())Ú	__class__Ú__name__©r)   s    r+   Ú__repr__zConstraint.__repr__f   s   € Ø�~‰~×&Ñ& q rÐ*¨TÑ1Ð1r-   N)r1   Ú
__module__Ú__qualname__Ú__doc__Úis_discreteÚ	event_dimr,   r3   © r-   r+   r   r   M   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.
    ©r7   r8   c                ó>   •— || _         || _        t        ‰| �  «        y ©N)Ú_is_discreteÚ
_event_dimÚsuperÚ__init__)r)   r7   r8   r0   s      €r+   rB   z_Dependent.__init__x   s   ø€ Ø'ˆÔØ#ˆŒÜ‰ÑÕr-   Úreturnc                 óT   — | j                   t        u rt        d«      ‚| j                   S )Nz,.is_discrete cannot be determined statically)r?   ÚNotImplementedr'   r2   s    r+   r7   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)r@   rE   r'   r2   s    r+   r8   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<   )rE   r?   r@   r;   )r)   r7   r8   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-   )r1   r4   r5   r6   rE   rB   ÚpropertyÚboolr7   Úintr8   rH   r,   Ú__classcell__©r0   s   @r+   r;   r;   j   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.r7   r8   rC   c                ó@   •— t         ‰| �  |«       || _        || _        y r>   )rA   rB   r?   r@   )r)   rW   r7   r8   r0   s       €r+   rB   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<   )rV   r?   r@   )r)   rW   s     r+   rH   z_DependentProperty.__call__Ø   s"   € ô "Ø˜D×-Ñ-¸¿¹ô
ð 	
r-   r>   )r1   r4   r5   r6   rE   r   r   r   rN   rO   rB   rH   rP   rQ   s   @r+   rV   rV   ³   sx   ø„ ñð6 ,0ð	$ð '5Ø#1ò	$à�X˜c 3˜hÑ'Ñ(ð	$ð ˜d‘^ð		$ð
 ˜C‘=ð	$ð 
õ	$ð	
˜8 C¨ HÑ-ð 	
Ð2F÷ 	
r-   rV   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   )rS   r   rO   Úbase_constraintÚreinterpreted_batch_ndimsrA   rB   )r)   r^   r_   r0   s      €r+   rB   z_IndependentConstraint.__init__ë   sM   ø€ Ü˜/¬:Ô6Ð6Ð6ÜÐ3´SÔ9Ð9Ð9Ø(¨AÒ-Ð-Ð-Ø.ˆÔØ)BˆÔ&Ü‰ÑÕr-   rC   c                 ó.   — | j                   j                  S r>   )r^   r7   r2   s    r+   r7   z"_IndependentConstraint.is_discreteó   s   € à×#Ñ#×/Ñ/Ð/r-   c                 óH   — | j                   j                  | j                  z   S r>   )r^   r8   r_   r2   s    r+   r8   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 )NzExpected value.dim() >= z	 but got ©éÿÿÿÿrd   )	r^   r,   Údimr_   r8   rJ   Ú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 )Nr/   ú(z, ú))r0   r1   Úreprr^   r_   r2   s    r+   r3   z_IndependentConstraint.__repr__  sA   € Ø—.‘.×)Ñ)¨!¨"Ð-Ð.¨a´°T×5IÑ5IÓ0JÐ/KÈ2Èd×NlÑNlÐMmÐmnÐoÐor-   )r1   r4   r5   r6   rB   rM   rN   r7   rO   r8   r,   r3   rP   rQ   s   @r+   r[   r[   ä   sQ   ø„ ñôð ð0˜Tò 0ó ð0ð ðO˜3ò Oó ðOòöp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   r/   r9   r(   s     r+   r,   z_Boolean.check  s   € Ø˜‘
˜u¨™zÑ*Ð*r-   N)r1   r4   r5   r6   r7   r,   r9   r-   r+   rp   rp     s   „ ñð €Kó+r-   rp   c                   ó   — e Zd ZdZdZdZd„ Zy)Ú_OneHotz'
    Constrain to one-hot vectors.
    Tr/   c                 ó€   — |dk(  |dk(  z  }|j                  d«      j                  d«      }|j                  d«      |z  S )Nr   r/   rd   )ÚsumÚeqrh   )r)   r*   Ú
is_booleanÚis_normalizeds       r+   r,   z_OneHot.check  s@   € Ø˜q‘j U¨a¡ZÑ0ˆ
ØŸ	™	 "›×(Ñ(¨Ó+ˆØ�~‰~˜bÓ! MÑ1Ð1r-   N)r1   r4   r5   r6   r7   r8   r,   r9   r-   r+   rs   rs     s   „ ñð €KØ€Ió2r-   rs   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_boundrA   rB   ©r)   r}   r~   r0   s      €r+   rB   z_IntegerInterval.__init__,  ó   ø€ Ø&ˆÔØ&ˆÔÜ‰ÑÕr-   c                 óR   — |dz  dk(  | j                   |k  z  || j                  k  z  S ©Nr/   r   ©r}   r~   r(   s     r+   r,   z_IntegerInterval.check1  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 ©Nr/   ú(lower_bound=z, upper_bound=rm   ©r0   r1   r}   r~   ©r)   Ú
fmt_strings     r+   r3   z_IntegerInterval.__repr__6  óJ   € Ø—^‘^×,Ñ,¨Q¨RÐ0ˆ
ØØ˜D×,Ñ,Ð-¨^¸D×<LÑ<LÐ;MÈQÐOñ	
ˆ
ð Ðr-   ©	r1   r4   r5   r6   r7   rB   r,   r3   rP   rQ   s   @r+   rz   rz   %  s   ø„ ñð €Kôò

ö
r-   rz   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~   rA   rB   ©r)   r~   r0   s     €r+   rB   z_IntegerLessThan.__init__E  ó   ø€ Ø&ˆÔÜ‰ÑÕr-   c                 ó2   — |dz  dk(  || j                   k  z  S r‚   ©r~   r(   s     r+   r,   z_IntegerLessThan.checkI  ó    € Ø˜‘	˜Q‘ 5¨D×,<Ñ,<Ñ#<Ñ=Ð=r-   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S ©Nr/   z(upper_bound=rm   ©r0   r1   r~   rˆ   s     r+   r3   z_IntegerLessThan.__repr__L  ó8   € Ø—^‘^×,Ñ,¨Q¨RÐ0ˆ
Ø˜ d×&6Ñ&6Ð%7°qÐ9Ñ9ˆ
ØÐr-   r‹   rQ   s   @r+   r�   r�   >  ó   ø„ ñð €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}   rA   rB   ©r)   r}   r0   s     €r+   rB   z_IntegerGreaterThan.__init__Y  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 ©Nr/   r†   rm   ©r0   r1   r}   rˆ   s     r+   r3   z_IntegerGreaterThan.__repr__`  r˜   r-   r‹   rQ   s   @r+   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>   r9   r(   s     r+   r,   z_Real.checkk  s   € Ø˜‰~Ðr-   N)r1   r4   r5   r6   r,   r9   r-   r+   r¥   r¥   f  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+   rB   z_GreaterThan.__init__t  r‘   r-   c                 ó    — | j                   |k  S r>   r    r(   s     r+   r,   z_GreaterThan.checkx  s   € Ø×Ñ %Ñ'Ð'r-   c                 ó^   — | j                   j                  dd  }|d| j                  › d�z  }|S r¢   r£   rˆ   s     r+   r3   z_GreaterThan.__repr__{  r˜   r-   ©r1   r4   r5   r6   rB   r,   r3   rP   rQ   s   @r+   r¨   r¨   o  ó   ø„ ñôò(ö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+   rB   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+   r3   z_GreaterThanEq.__repr__�  r˜   r-   r¬   rQ   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+   rB   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+   r3   z_LessThan.__repr__Ÿ  r˜   r-   r¬   rQ   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+   rB   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+   r3   z_Interval.__repr__²  rŠ   r-   r¬   rQ   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+   rB   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+   r3   z_HalfOpenInterval.__repr__Ç  rŠ   r-   r¬   rQ   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`.
    r/   c                 ó‚   — t        j                  |dk\  d¬«      |j                  d«      dz
  j                  «       dk  z  S )Nr   rd   ©re   r/   ç�íµ ÷Æ°>)Útorchrh   ru   Úabsr(   s     r+   r,   z_Simplex.check×  s7   € Ü�y‰y˜ !™¨Ô,°·±¸2³ÀÑ1B×0GÑ0GÓ0IÈDÑ0PÑQÐQr-   N©r1   r4   r5   r6   r8   r,   r9   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``.
    Tr/   c                 ó   — || _         y r>   r“   )r)   r~   s     r+   rB   z_Multinomial.__init__ç  s
   € Ø&ˆÕr-   c                 ól   — |dk\  j                  d¬«      |j                  d¬«      | j                  k  z  S )Nr   rd   rÅ   )rh   ru   r~   rK   s     r+   r,   z_Multinomial.checkê  s1   € Ø�Q‘�|‰| ˆ|Ó# q§u¡u° u£}¸×8HÑ8HÑ'HÑIÐIr-   N)r1   r4   r5   r6   r7   r8   rB   r,   r9   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éþÿÿÿrc   rd   r   )ÚtrilÚviewrg   Ú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É   r9   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Ò   rc   rd   r   )Údim1Údim2)rÓ   rÔ   rg   rÕ   Údiagonal)r)   r*   rÖ   r   Úpositive_diagonals        r+   r,   z_LowerCholesky.check  s{   € Ø—Z‘Z“\ˆ
à˜5Ñ ×&Ñ& u§{¡{°3°BÐ'7¸%Ñ'?Ó@×DÑDÀRÓHÈÑKð 	ð #Ÿ^™^°¸"˜^Ó=ÀÑA×FÑFÀrÓJÈ1ÑMÐØÐ"3Ñ3Ð3r-   NrÉ   r9   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 )Nrd   é
   rÅ   ç      ð?)rÇ   ÚfinfoÚdtypeÚepsÚsizeÚlinalgÚnormÚdetachrÈ   Úlerh   rØ   r,   )r)   r*   ÚtolÚrow_normÚunit_row_norms        r+   r,   z_CorrCholesky.check  s”   € ä�K‰K˜Ÿ™Ó$×(Ñ(¨5¯:©:°b«>Ñ9¸BÑ>ð 	ô —<‘<×$Ñ$ U§\¡\£^¸Ð$Ó<ˆØ! C™×,Ñ,Ó.×1Ñ1°#Ó6×:Ñ:¸rÐ:ÓBˆÜÓ×%Ñ% eÓ,¨}Ñ<Ð<r-   NrÉ   r9   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Ò   rd   )ræ   Ú
fill_valuerä   Údevice)rÇ   Úfullrg   rN   rò   r(   s     r+   r,   z_Square.check#  sG   € Ü�z‰zØ—‘˜S˜bÐ!ØŸ™ B™¨5¯;©;°r©?Ñ:Ü—*‘*Ø—<‘<ô	
ð 	
r-   NrÉ   r9   r-   r+   rï   rï     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Ò   rd   )rA   r,   rh   rÇ   ÚiscloseÚmT)r)   r*   Úsquare_checkr0   s      €r+   r,   z_Symmetric.check1  sP   ø€ Ü‘w‘} UÓ+ˆØ×ÑÔ!ØÐÜ�}‰}˜U E§H¡H°4Ô8×<Ñ<¸RÓ@×DÑDÀRÓHÐHr-   ©r1   r4   r5   r6   r,   rP   rQ   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   rd   )rA   r,   rh   rÇ   rç   ÚeigvalshÚge©r)   r*   Ú	sym_checkr0   s      €r+   r,   z_PositiveSemidefinite.check=  sK   ø€ Ü‘G‘M %Ó(ˆ	Ø�}‰}ŒØÐÜ�|‰|×$Ñ$ UÓ+×.Ñ.¨qÓ1×5Ñ5°bÓ9Ð9r-   rû   rQ   s   @r+   rý   rý   8  ó   ø„ ñ÷:ð :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]   )rA   r,   rh   rÇ   rç   Úcholesky_exÚinforv   r  s      €r+   r,   z_PositiveDefinite.checkI  sF   ø€ Ü‘G‘M %Ó(ˆ	Ø�}‰}ŒØÐÜ�|‰|×'Ñ'¨Ó.×3Ñ3×6Ñ6°qÓ9Ð9r-   rû   rQ   s   @r+   r  r  D  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>   ©rS   r   ©Ú.0Úcs     r+   ú	<genexpr>z _Cat.__init__.<locals>.<genexpr>X  ó   è ø€ Ò;°”:˜a¤×,Ñ;ùó   ‚r/   )rh   ÚlistÚcseqÚlenÚlengthsre   rA   rB   )r)   r  re   r  r0   s       €r+   rB   z_Cat.__init__W  sw   ø€ ÜÑ;°dÔ;Ô;Ð;Ð;Ü˜“JˆŒ	Øˆ?Ø�cœC §	¡	›NÑ*ˆGÜ˜G“}ˆŒÜ�4—<‘<Ó ¤C¨¯	©	£NÒ2Ð2Ð2ØˆŒÜ‰ÑÕr-   rC   c                 ó:   — t        d„ | j                  D «       «      S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr>   ©r7   r  s     r+   r  z#_Cat.is_discrete.<locals>.<genexpr>c  ó   è ø€ Ò4 Q�1—=•=Ñ4ùó   ‚©Úanyr  r2   s    r+   r7   z_Cat.is_discretea  ó   € äÑ4¨$¯)©)Ô4Ó4Ð4r-   c                 ó:   — t        d„ | j                  D «       «      S )Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr>   ©r8   r  s     r+   r  z!_Cat.event_dim.<locals>.<genexpr>g  s   è ø€ Ò2 1�1—;•;Ñ2ùr  )Úmaxr  r2   s    r+   r8   z_Cat.event_dime  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]   )	re   Úzipr  r  ÚnarrowÚappendr,   rÇ   r   )r)   r*   ÚchecksÚstartÚconstrÚlengthÚvs          r+   r,   z
_Cat.checki  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©r1   r4   r5   r6   rB   rM   rN   r7   rO   r8   r,   rP   rQ   s   @r+   r
  r
  P  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  )rh   r  r  re   rA   rB   )r)   r  re   r0   s      €r+   rB   z_Stack.__init__{  s4   ø€ ÜÑ;°dÔ;Ô;Ð;Ð;Ü˜“JˆŒ	ØˆŒÜ‰ÑÕr-   rC   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  r2   s    r+   r7   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>   r"  r  s     r+   r  z#_Stack.event_dim.<locals>.<genexpr>‡  s   è ø€ Ò1 !�!—+•+Ñ1ùr  r   r/   )r#  r  re   )r)   re   s     r+   r8   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>   )	re   Úrangeræ   ÚselectrÇ   r"   r%  r  r,   )r)   r*   ÚiÚvsr,  r*  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-  rQ   s   @r+   r/  r/  t  sH   ø„ ñõð ð5˜Tò 5ó ð5ð ð˜3ò ó ðö
r-   r/  r/   g        râ   )?Útypingr   r   r   rÇ   Ú__all__r   r;   r   rM   rV   r[   rp   rs   rz   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"   r9   r-   r+   ú<module>r=     sG  ð÷ +Ñ *ðóB ò €÷F2ñ 2ô:,N�ô ,Nò^.ô4.
˜ :ô .
ôb%p˜Zô %pôP+ˆ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-   