ph SrSSKrSSKrSSKJr SSKrSSKJr SSK J r J r J r J r JrJrJr SSKJrJr SSKJr SS KJr SS KJrJr SS KJr SS KJrJrJ r \RB"\"5r#S r$\RJ"S\$5r&Sr'Sr(Sr)Sr*"SS\"S/SQ55r+"SS\5r,"SS\"SSS/55r-"SS\"SSS/55r.Sr/S r0S!r1S"r2S#r3S$r4"S%S&5r5S'r6S,S(jr7S-S)jr8S*r9S+r:g).zN Methods for coarse-graining systems to different levels of spatial analysis. N) namedtuple)entropy)computeconfig constantsconvert distributionutilsvalidate)ConditionallyDependentErrorStateUnreachableError) NodeLabels)irreducible_purviews)expand_node_tpmgenerate_nodes) Subsystem)is_state_by_statemarginalize_out tpm_indices partition_listsc<[[[U555$)z8Generate a new set of node indices, the size of indices.)tuplerangelen)indicess E/home/james-whalen/.local/lib/python3.13/site-packages/pyphi/macro.pyreindexr!s s7|$ %%cj[R"UVs/sHn[U5PM snSS9$s snf)z;Reconstruct the network TPM from a collection of node TPMs.)axis)npstackr) node_tpmstpms rrebuild_system_tpmr(&s* 88Y?Yc_S)Y?b II?s0cbURS::aU$UR5S[U54$)a/Remove singleton dimensions from the TPM. Singleton dimensions are created by conditioning on a set of elements. This removes those elements from the TPM, leaving a TPM that only describes the non-conditioned elements. Note that indices used in the original TPM must be reindexed for the smaller TPM. .)ndimsqueezerr's rremove_singleton_dimensionsr.+s/ xx1} ;;=k#.. //r c*/nURHtnURnURHDnURURU5(aM&XbR ;dM7[ U/U5nMF URU5 Mv [U5n[R"U5n[R"UR5n[R"U[RRXqS- 55n[R "U5$)zeIterate the TPM for the given number of timesteps. Returns: np.ndarray: tpm * (noise_tpm^(t-1)) r)nodestpm_oninputs in_same_boxindexoutput_indicesrappendr(r state_by_node2state_by_stater'r$dotlinalg matrix_powerstate_by_state2state_by_node) systemstepsblackboxr&nodenode_tpm input_node noised_tpmr's rrun_tpmrC=sI ;;++J'' J??!8!88. |XFH& "$I.J55jAJ  . .vzz :C &&bii,,ZC DC  / / 44r cN\rSrSrSr\S5r\S5r\S5r Sr Sr g) SystemAttrs[zAn immutable container that holds all the attributes of a subsystem. Versions of this object are passed down the steps of the micro-to-macro pipeline. c[UR5SS:Xde[SUR55n[XR5$)z"Return the labels for macro nodes.rc3D# UHnSRU5v M g7f)zm{}N)format).0is r *SystemAttrs.node_labels..fsA/@!ell1oo/@s )list node_indicesr)selflabelss r node_labelsSystemAttrs.node_labelsbsID%%&q)Q...At/@/@AA&"3"344r c[URURURURUR 5$N)rr'cmstaterOrRrPs rr0SystemAttrs.nodesis2dhhT=N=N"..0 0r cn[URURURUR5$rU)rEr'rVrOrW)r<s rpackSystemAttrs.packns*6::vyy&2E2E!<<) )r cURUlURUlURUlURUlURUlUR UlgrU)r'rVrOrRr0rW)rPr<s rapplySystemAttrs.applyssJXX GG "//!--zz zz r N) __name__ __module__ __qualname____firstlineno____doc__propertyrRr0 staticmethodr[r^__static_attributes__r`r rrErE[sH 55 00))"r rE)r'rVrOrWc^\rSrSrSrSU4Sjjr\S5r\S5r\S5r Sr \S5r \ S 5r \ S 5r\ S 5rS rSS jrSrSrSrSrU4SjrU4SjrSrU=r$)MacroSubsystem|aA subclass of |Subsystem| implementing macro computations. This subsystem performs blackboxing and coarse-graining of elements. Unlike |Subsystem|, whose TPM has dimensionality equal to that of the subsystem's network and represents nodes external to the system using singleton dimensions, |MacroSubsystem| squeezes the TPM to remove these singletons. As a result, the node indices of the system are also squeezed to ``0..n`` so they properly index the TPM, and the state-tuple is reduced to the size of the system. After each macro update (temporal blackboxing, spatial blackboxing, and spatial coarse-graining) the TPM, CM, nodes, and state are updated so that they correctly represent the updated system. c >URRU5n X lXlX`lXplXl[T U]!XXU5 [R"Xx5 [RU5n URU 5n Ub7[R "U5 UR5nURXz5n US:wa-Uce[R"U5 UR!XgU 5n UbUR#Xz5n UbB[R "U5 UR5nUR%XR&U 5n U R)U5 [R*"U5 g)Nr)rRcoerce_to_indices network_statemicro_node_indices time_scaler> coarse_grainsuper__init__r blackbox_and_coarse_grainrEr[_squeezer_blackbox_partial_noise_blackbox_time_blackbox_space_coarsegrain_spaceis_cutr^ subsystem) rPnetworkrWr0cut mice_cacherpr>rqror< __class__s rrsMacroSubsystem.__init__sO%00BB5I#"4$ ( );*M**8B!!$'v&     h ''')H11(CF ?' ''    +((vFF  ))(;F  #  ! !, /'//1L,,\;;OF T4 r cUR[UR5:Xde[UR5n[UR5nUR[ R "X5n[R"XR5n[U5n[X#XE5n[SU55n[X#XT5$)zSqueeze out all singleton dimensions in the Subsystem. Reindexes the subsystem so that the nodes are ``0..n`` where ``n`` is the number of internal indices in the system. c38# UHoRv M g7frU)r1)rJr?s rrL*MacroSubsystem._squeeze..s ?)rOrr'r.rVr$ix_r state_ofrWrrr(rE)r<internal_indicesr'rVrWrOr0s rruMacroSubsystem._squeezes""k&**&====&vzz2)&**5 YYrvv.A B/>/0 s<! ? ??3L88r c/nURHbnURnURH2nURXSR5(dM%[ U/U5nM4 UR U5 Md [U5nURUS9$)z6Noise connections from hidden elements to other boxes.r-) r0r1r2 hidden_fromr4rr6r(_replace)r>r<r&r?r@rAr's rrv&MacroSubsystem._blackbox_partial_noises~ LLD{{H"kk '' JJ??. |XFH*   X & !!+3''r cUR5n[X U5n[UR5n[R "XD45n[ X5URUR5$)z3Black box the CM and TPM over the given time_scale.)rrCrrOr$onesrErW)rpr>r<r'nrVs rrwMacroSubsystem._blackbox_timesX##%f(3 ## $ WWaV_3F$7$7FFr ch[URUR5nUR[ U5:Xde[ U5n[ U5n[R"XD45n[R"[U5SS9HvupgURRU5nURRUn UR[R "X5R#5S:dMpSXVU4'Mx UR%UR&5n UR(n [+X5X5$)aEBlackbox the TPM and CM in space. Conditions the TPM on the current value of the hidden nodes. The CM is set to universal connectivity. .. TODO: change this ^ This shrinks the size of the TPM by the number of hidden indices; now there is only `len(output_indices)` dimensions in the TPM and in the state of the subsystem. r*repeatrr)rhidden_indicesr'r5rr.rr$zeros itertoolsproductrr> outputs_of partitionrVrsum macro_staterW macro_indicesrE) rPr>r<r'rrVrKjoutputstorWrOs rrxMacroSubsystem._blackbox_spacesh55vzzB&&+c*::::)#. M XXqf %%eAhq9DAmm..q1G((+Bwwrvvg*+//1A5a4 :$$V\\2-- 3L88r cURURU(+S9nURnURUR5n[ U5n[ R"Xf45n[X7XE5$)z&Spatially coarse-grain the TPM and CM.check_independence) macro_tpmr'rrrWrr$rrE)rqrzr<r'rOrWrrVs rry!MacroSubsystem._coarsegrain_space sm$$ JJJ%9$11 ((6   WWaV_3L88r cUR$)zThe indices of this system to be cut for |big_phi| computations. For macro computations the cut is applied to the underlying micro-system. )rorXs r cut_indicesMacroSubsystem.cut_indices/s&&&r c## [R"URSS9H:nURU5nURR U5(dM6Uv M< g7f)zThe mechanisms of this system that are currently cut. Note that although ``cut_indices`` returns micro indices, this returns macro mechanisms. Yields: tuple[int] TnonemptyN)r powersetrO macro2micror}splits_mechanism)rP mechanismmicro_mechanisms rcut_mechanismsMacroSubsystem.cut_mechanisms8sM(9(9DII"..y9Oxx((99Js AA! A!c.URR$)zSLabels for the nodes that can be cut. These are the labels of the micro elements. )r|rRrXs rcut_node_labelsMacroSubsystem.cut_node_labelsGs ||'''r c [URURURUURUR UR S9$)zReturn a cut version of this |MacroSubsystem|. Args: cut (Cut): The cut to apply to this |MacroSubsystem|. Returns: MacroSubsystem: The cut version of this |MacroSubsystem|. )r}rpr>rq)rjr|rnrorpr>rq)rPr}s r apply_cutMacroSubsystem.apply_cutOsD LL     # #]]**, ,r cp[R"UR5n[URXU5$)z>Override Subsystem implementation using Network-level indices.)r rrOrrV)rP directionrpurviews all_purviewss rpotential_purviews!MacroSubsystem.potential_purviewsbs.~~d&7&78 # GGY<9 9r cSnUR(aTUR(aCU"URRU5nU"URR[U55$UR(aU"URRU5$UR(aU"URRU5$U$)zTReturn all micro indices which compose the elements specified by ``macro_indices``. c~^[RRU4SjU55n[[ U55$)Nc3.># UH nTUv M g7frUr`)rJrKrs rrLEMacroSubsystem.macro2micro..from_partition..ms:5&3 ! m)rchain from_iterablersorted)rr micro_indicess` rfrom_partition2MacroSubsystem.macro2micro..from_partitionls4%OO99:5&3:55M ./ /r )r>rqrr)rPrrcg_micro_indicess rrMacroSubsystem.macro2microhs 0 ==T..-d.?.?.I.I.; = !$--"9"9")*:";= = ]]!$--"9"9=I I   !$"3"3"="=}M Mr c UR(d [S5e[[[ UR U55R URR555$)zaGiven a set of macro elements, return the blackbox output elements which compose these elements. zSystem is not blackboxed)r> ValueErrorrrsetr intersectionr5)rPrs rmacro2blackbox_outputs%MacroSubsystem.macro2blackbox_outputs|sT}}78 8VC   ] + ,t}}33 467 7r c8S[UR5-S-$)NzMacroSubsystem())reprr0rXs r__repr__MacroSubsystem.__repr__s 4 #33c99r c[U5$rU)rrXs r__str__MacroSubsystem.__str__s Dzr c>[U5[U5:wag[TU] U5=(aY URUR:H=(a9 URUR:H=(a UR UR :H$)zhTwo macro systems are equal if each underlying |Subsystem| is equal and all macro attributes are equal. F)typerr__eq__rpr>rq)rPotherrs rrMacroSubsystem.__eq__sp :e $u%85#3#338 /8!!U%7%77 9r cv>[[TU] 5URURUR 45$rU)hashrr__hash__rpr>rq)rPrs rrMacroSubsystem.__hash__s7 W   __ ]]    ! !r )r>rqrornrp)NNNrNN)F)rarbrcrdrersrgrurvrwrxryrfrrrrrrrrrrrrh __classcell__)rs@rrjrj|s(IM;?3!j998((  G G9> 9 9''    ((,&9 ( 7: 9!!r rjc`\rSrSrSr\S5r\S5rSrSr Sr Sr S r S S jr S rg ) CoarseGrainizRepresents a coarse graining of a collection of nodes. Attributes: partition (tuple[tuple]): The partition of micro-elements into macro-elements. grouping (tuple[tuple[tuple]]): The grouping of micro-states into macro-states. cL[[SUR555$)z>Indices of micro elements represented in this coarse-graining.c36# UHoHo"v M M g7frUr`rJpartidxs rrL,CoarseGrain.micro_indices..KNDdsCdCNrrrrXs rrCoarseGrain.micro_indicesVKDNNKKLLr cP[[[UR555$)z2Indices of macro elements of this coarse-graining.)rrrrrXs rrCoarseGrain.macro_indicessU3t~~./00r c,[UR5$rUrrrXs r__len__CoarseGrain.__len__4>>""r c^[[UR[UR555m[ U4SjUR 55n[ XR5$)a=Re-index this coarse graining to use squeezed indices. The output grouping is translated to use indices ``0..n``, where ``n`` is the number of micro indices in the coarse-graining. Re-indexing does not effect the state grouping, which is already index-independent. Returns: CoarseGrain: A new |CoarseGrain| object, indexed from ``0..n``. Example: >>> partition = ((1, 2),) >>> grouping = (((0,), (1, 2)),) >>> coarse_grain = CoarseGrain(partition, grouping) >>> coarse_grain.reindex() CoarseGrain(partition=((0, 1),), grouping=(((0,), (1, 2)),)) c3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7frUr`rJr4_maps rrL0CoarseGrain.reindex...15%$u+5rNrrJgrouprs rrL&CoarseGrain.reindex..& ' 151 1 1'"%)dictziprrrrrgrouping)rPrrs @rrCoarseGrain.reindexsS"C**GD4F4F,GHI   9mm44r c^^^[T5[TR5:XdeTR5m[R"T5m[ UUU4SjTR 55$)aTranslate a micro state to a macro state Args: micro_state (tuple[int]): The state of the micro nodes in this coarse-graining. Returns: tuple[int]: The state of the macro system, translated as specified by this coarse-graining. Example: >>> coarse_grain = CoarseGrain(((1, 2),), (((0,), (1, 2)),)) >>> coarse_grain.macro_state((0, 0)) (0,) >>> coarse_grain.macro_state((1, 0)) (1,) >>> coarse_grain.macro_state((1, 1)) (1,) c3># UHAn[T[TRU55TRUS;aSOSv MC g7f)rrN)rrNrr)rJrK micro_state reindexedrPs rrL*CoarseGrain.macro_state..sR20k$y/B/B1/E*FGH a(+,Q1230sA A )rrrr$arrayrrrPr r s``@rrCoarseGrain.macro_states^(;3t'9'9#:::: LLN hh{+ 2"0022 2r c[R"[UR55nUVs/sH(n[R "UR U55PM* nn[R"U5$s snf)a Return a mapping from micro-state to the macro-states based on the partition and state grouping of this coarse-grain. Return: (nd.ndarray): A mapping from micro-states to macro-states. The |ith| entry in the mapping is the macro-state corresponding to the |ith| micro-state. ) r all_statesrrr state2le_indexrr$r)rP micro_statesr mappings r make_mappingCoarseGrain.make_mappingsk''D,>,>(?@ '34&2{))$*:*:;*GH&2 4xx  4s/A5c[R"USS9 UR5nS[UR5-n[ R "X345n[S[UR5-5n[R"USS9nUHupxXBUX(4==XU4- ss'M [ R"UV s/sHn [R"U 5PM sn 5$s sn f)zCreate a state-by-state coarse-grained macro TPM. Args: micro_tpm (nd.array): The state-by-state TPM of the micro-system. Returns: np.ndarray: The state-by-state TPM of the macro-system. Frr*r)r r'rrrr$rrrrrrr normalize) rPstate_by_state_micro_tpmrnum_macro_statesrrmicro_state_transitionsprevious_state current_staterows r macro_tpm_sbsCoarseGrain.macro_tpm_sbss  -%H##%D$6$6 77HH.AB Q#d&8&8"99: "+"3"3L"K .E )N n-w/EE F()FG I F.E xx J //4 JKKJs C(c[U5(d[R"U5nURU5nU(a[R "U5 [R "U5$)aCreate a coarse-grained macro TPM. Args: micro_tpm (nd.array): The TPM of the micro-system. check_independence (bool): Whether to check that the macro TPM is conditionally independent. Raises: ConditionallyDependentError: If ``check_independence`` is ``True`` and the macro TPM is not conditionally independent. Returns: np.ndarray: The state-by-node TPM of the macro-system. )rr r7r r conditionally_independentr;)rP micro_tpmrrs rrCoarseGrain.macro_tpm!sQ!++<>r r`N)T)rarbrcrdrerfrrrrrrr rrhr`r rrrsQMM11#502@!$L:?r rrrcl\rSrSrSr\S5r\S5r\S5rSr Sr Sr S r S r S rS rg )Blackboxi;zClass representing a blackboxing of a system. Attributes: partition (tuple[tuple[int]]): The partition of nodes into boxes. output_indices (tuple[int]): Outputs of the blackboxes. c|[[[UR5[UR5- 55$)z*All elements hidden inside the blackboxes.)rrrrr5rXs rrBlackbox.hidden_indicesEs8VC 2 23 3 34567 7r cL[[SUR555$)z.Indices of micro-elements in this blackboxing.c36# UHoHo"v M M g7frUr`rs rrL)Blackbox.micro_indices..NrrrrXs rrBlackbox.micro_indicesKrr c,[UR5$)z3Fresh indices of macro-elements of the blackboxing.)rr5rXs rrBlackbox.macro_indicesPst**++r c,[UR5$rUrrXs rrBlackbox.__len__Urr cURUn[U5RUR5n[ [ U55$)zThe outputs of the partition at ``partition_index``. Note that this returns a tuple of element indices, since coarse- grained blackboxes may have multiple outputs. )rrrr5rr)rPpartition_indexrrs rrBlackbox.outputs_ofXs; NN?3 i.--d.A.ABVG_%%r c^[[UR[UR555m[ U4SjUR 55n[ U4SjUR 55n[X5$)aGSqueeze the indices of this blackboxing to ``0..n``. Returns: Blackbox: a new, reindexed |Blackbox|. Example: >>> partition = ((3,), (2, 4)) >>> output_indices = (2, 3) >>> blackbox = Blackbox(partition, output_indices) >>> blackbox.reindex() Blackbox(partition=((1,), (0, 2)), output_indices=(0, 1)) c3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7frUr`rs rrL-Blackbox.reindex...qrrNrrs rrL#Blackbox.reindex..prrc3.># UH nTUv M g7frUr`)rJrKrs rrLr9tsD0C1tAw0Cr)rrrrrrr5r')rPrr5rs @rrBlackbox.reindexbseC**GD4F4F,GHI   D0C0CDD 22r c[U5[UR5:XdeUR5n[R"UR U5$)zCompute the macro-state of this blackbox. This is just the state of the blackbox's output indices. Args: micro_state (tuple[int]): The state of the micro-elements in the blackbox. Returns: tuple[int]: The state of the output indices. )rrrr rr5rs rrBlackbox.macro_statexsD;3t'9'9#::::LLN ~~i66 DDr cXR;deX R;deURHnX;dM X#;dM g g)z>Return ``True`` if nodes ``a`` and ``b``` are in the same box.TF)rr)rPabrs rr3Blackbox.in_same_boxsE&&&&&&&&&&NNDyQY#r cXXR;=(a URX5(+$)z=Return True if ``a`` is hidden in a different box than ``b``.)rr3)rPr?r@s rrBlackbox.hidden_froms$'''F0@0@0F,FFr r`N)rarbrcrdrerfrrrrrrrr3rrhr`r rr'r';se77 MM,,#&3,E" Gr r'r5cvU[:a[[U5$[SR [55e)a_Return a list of partitions of the |N| binary nodes. Args: N (int): The number of nodes under consideration. Returns: list[list]: A list of lists, where each inner list is the set of micro-elements corresponding to a macro-element. Example: >>> _partitions_list(3) [[[0, 1], [2]], [[0, 2], [1]], [[0], [1, 2]], [[0], [1], [2]]] zBPartition lists not yet available for system with {} nodes or more) _NUM_PRECOMPUTED_PARTITION_LISTSrN_partition_listsrrI)Ns r_partitions_listrHs= ,-$Q'(( "F#CDF Fr c#^# [T5n[U5nUS:a[[U55/US'UHn[ U4SjU55v M g7f)a Return a list of all possible coarse grains of a network. Args: indices (tuple[int]): The micro indices to partition. Yields: tuple[tuple]: A possible partition. Each element of the tuple is a tuple of micro-elements which correspond to macro-elements. rr"c3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7frUr`)rJrKrs rrL+all_partitions...s3d'!*drNr)rJrrs rrL!all_partitions..s&+ )3d333 )rN)rrHrNrr)rr partitionsrs` rall_partitionsrOsZ G A!!$J1uuQx.) 2 + )++ + sAAc#f# [U5(d [S5eUVs/sH0n[U5S:a[[U5S-5OS/S///PM2 nn[R "U6H9n[SU55(dM[ [ SU555v M; gs snf7f)aXReturn all possible groupings of states for a particular coarse graining (partition) of a network. Args: partition (tuple[tuple]): A partition of micro-elements into macro elements. Yields: tuple[tuple[tuple]]: A grouping of micro-states into macro states of system. TODO: document exactly how to interpret the grouping. z:Each part of the partition must have at least one element.rrc3># UHn[U5S:v M g7f)N)r)rJelements rrL all_groupings..s8xGs7|axsc3F# UHn[SU55v M g7f)c38# UHn[U5v M g7frUr)rJrWs rrL*all_groupings...s#EfUE%LLfrNr)rJstatess rrLrTs%6,4&$#Ef#EEE,4s!N)allrrrHrrr)rrmicro_groupingsrs r all_groupingsr[s y>>$% %6?@5>T;>d)a-'D A 6 cA3ZL)5>@%%7 8x8 8 86,4667 78@s B17B,-B1 'B1c#n# [U5H"n[U5Hn[X5v M M$ g7f)zGenerator over all possible |CoarseGrains| of these indices. Args: indices (tuple[int]): Node indices to coarse grain. Yields: CoarseGrain: The next |CoarseGrain| for ``indices``. N)rOr[r)rrrs rall_coarse_grainsr]s0$G, %i0Hi2 21-s35c## [UR5H;n[U5H)n[X5n[R "X5 Uv M+ M= g![ a M?f=f7f)zGenerator over all |CoarseGrains| for the given blackbox. If a box has multiple outputs, those outputs are partitioned into the same coarse-grain macro-element. N)rOr5r[rr rtr)r>rrrqs rall_coarse_grains_for_blackboxr_sc $H$;$;< %i0H&y;L 228J  1=   s(2A)A A) A&"A)%A&&A)c## [U5HFn[R"U5H)n[X5n[R "U5 Uv M+ MH g![ a M?f=f7f)zGenerator over all possible blackboxings of these indices. Args: indices (tuple[int]): Nodes to blackbox. Yields: Blackbox: The next |Blackbox| of ``indices``. N)rOr rr'r r>r)rrr5r>s rall_blackboxesrasb$G, $nnW5N :H !!(+N 6-  s(3A*A A* A'#A*&A''A*c:\rSrSrSrSSjrSr\S5rSr g) MacroNetworkiaA coarse-grained network of nodes. See the :ref:`macro-micro` example in the documentation for more information. Attributes: network (Network): The network object of the macro-system. phi (float): The |big_phi| of the network's major complex. micro_network (Network): The network object of the corresponding micro system. micro_phi (float): The |big_phi| of the major complex of the corresponding micro-system. coarse_grain (CoarseGrain): The coarse-graining of micro-elements into macro-elements. time_scale (int): The time scale the macro-network run over. blackbox (Blackbox): The blackboxing of micro elements in the network. emergence (float): The difference between the |big_phi| of the macro- and the micro-system. NcXXlX lX0lX@lX`lXPlXplgrU)r|r<phi micro_phirprqr>)rPr|r< macro_phirfrqrpr>s rrsMacroNetwork.__init__&s(  "$( r cNSRURUR5$)Nz$MacroNetwork(phi={0}, emergence={1}))rIre emergencerXs rrMacroNetwork.__str__1s"5<< HHdnn& &r cd[URUR- [R5$)z?Difference between the |big_phi| of the macro and micro systems)roundrerfr PRECISIONrXs rrjMacroNetwork.emergence5s$TXX.0@0@AAr )r>rqrfr|rer<rp)rN) rarbrcrdrersrrfrjrhr`r rrcrcs,*)- !&BBr rcc[S5n[SS5n[U5HAn[XUUS9n[ R "U5nXs- [R:dM=UnUnMC X44$![a MUf=f)a.Find the maximal coarse-graining of a micro-system. Args: network (Network): The network in question. state (tuple[int]): The state of the network. internal_indices (tuple[int]): Nodes in the micro-system. Returns: tuple[int, CoarseGrain]: The phi-value of the maximal |CoarseGrain|. -infr`rq) floatrr]rjr rrerEPSILON)r|rWrmax_phimax_coarse_grainrqr{res rcoarse_grainingrw;sFmG"2r*)*:;  &w7G4@BI kk)$ MY.. .G+ <  &&+   s A++ A98A9c #^^# UcS/nU4SjnU4Sjn[R"UR5H:nUH1nU"U5H"n U"X5Hn [XUUU U S9v M M$ M3 M< g![[ 4a M7f=f7f)z:Generator over all possible macro-systems for the network.Nrc.>T(dS/$[U5$rU)ra)r< do_blackboxs r blackboxes%all_macro_systems..blackboxes_s6Mf%%r cJ>T(dS/$Uc [U5$[U5$rU)r]r_)r>r<do_coarse_grains r coarse_grains(all_macro_systems..coarse_grainses)6M  $V, ,-h77r )rpr>rq)r rrOrjrr ) r|rWrzr~ time_scalesr{rr<rpr>rqs `` rall_macro_systemsrYsc & 8..!5!56%J&v.$1($CL!,#F'1%-)5 77%D/&7279! !s*AB A6%B 6B B  B B c T[R"X5Rn[S5nSn[ XUUUS9Hjn[R"U5n X- [ R :dM1U n[UU UURURURURS9nMl U$)ajCheck for the emergence of a micro-system into a macro-system. Checks all possible blackboxings and coarse-grainings of a system to find the spatial scale with maximum integrated information. Use the ``do_blackbox`` and ``do_coarse_grain`` args to specifiy whether to use blackboxing, coarse-graining, or both. The default is to just coarse-grain the system. Args: network (Network): The network of the micro-system under investigation. state (tuple[int]): The state of the network. do_blackbox (bool): Set to ``True`` to enable blackboxing. Defaults to ``False``. do_coarse_grain (bool): Set to ``True`` to enable coarse-graining. Defaults to ``True``. time_scales (list[int]): List of all time steps over which to check for emergence. Returns: MacroNetwork: The maximal macro-system generated from the micro-system. rqN)rzr~r)r|rgrfr<rpr>rq) r major_complexrersrrrtrcrorpr>rq) r|rWrzr~rrfru max_networkr{res rrjrj~s2%%g599IFmGK&w;7F3>@ kk)$ MY.. .G&# 33$//"++&335K@ r c /n[R"URSS9nUHn[XU5n[R "U5nUR [U5XdS/5 [U5HBn[XUUS9n[R "U5nUR [U5XdU/5 MD M U$![a MYf=f)NTrrr) r rrOrrrer6rr]rjr ) r|rW list_of_phisystemsr<micro_subsystemrerqr{s r phi_by_grainrsKnnW11DAG#GF;kk/*C0#tDE-f5L *768DF ++i(C   I\J K6   /  s5 B== C  C c [R"U5 [R"UR5n[ R "US5n[ R "UVs/sHn[X2S5PM sn5$s snf)uReturn the effective information of the given network. .. note:: For details, see: Hoel, Erik P., Larissa Albantakis, and Giulio Tononi. “Quantifying causal emergence shows that macro can beat micro.” Proceedings of the National Academy of Sciences 110.49 (2013): 19790-19795. Available online: `doi: 10.1073/pnas.1314922110 `_. rg@)r is_networkr r7r'r$meanr)r|sbs_tpmavg_repertoire repertoires reffective_inforsn  227;;?GWWWa(N 77&-/&- J<&-/ 00/s"A?)FFN)FTN);rerlogging collectionsrnumpyr$ scipy.statsrrrrr r r r exceptionsr rrQrr|rr?rrr{rr'rrr getLoggerralogrE load_datarFrr(r.rCrErjrr'rHrOr[r]r_rarcrwrrjrrr`r rrs9 "PPPJ)1 @@!$& ??#4#CE& J 0$5<"*]CE"Bb!Yb!J W?*][*,EFW?t[Gz*{4D&EF[G|F,+(76 3  *'B'BT'<JO"&"!JBF.d20r