text:
Automatically generated by Mendeley Desktop 1.14
Any changes to this file will be lost if it is regenerated by Mendeley.

BibTeX export options can be customized via Options -> BibTeX in Mendeley Desktop

@inproceedings{Silver2010,
abstract = {This paper introduces a Monte-Carlo algorithm for online planning in large POMDPs. The algorithm combines a Monte-Carlo update of the agent's belief state with a Monte-Carlo tree search from the current belief state. The new algorithm, POMCP, has two important properties. First, Monte- Carlo sampling is used to break the curse of dimensionality both during belief state updates and during planning. Second, only a black box simulator of the POMDP is required, rather than explicit probability distributions. These properties enable POMCP to plan e ectively in signi cantly larger POMDPs than has previously been possible. We demonstrate its effectiveness in three large POMDPs. We scale up a well-known benchmark problem, rocksample, by several orders of magnitude. We also introduce two challenging new POMDPs: 10 X 10 battleship and partially observable PacMan, with approximately 10\^{}18 and 10\^{}56 states respectively. Our Monte- Carlo planning algorithm achieved a high level of performance with no prior knowledge, and was also able to exploit simple domain knowledge to achieve better results with less search. POMCP is the rst general purpose planner to achieve high performance in such large and unfactored POMDPs.},
author = {Silver, D and Veness, J},
booktitle = {Advances in neural information processing systems},
file = {:home/zach/Util/Papers/Monte-Carlo Planning in Large POMDPs - Silver, Veness - 2010.pdf:pdf},
isbn = {9781617823800},
pages = {2164----2172},
title = {{Monte-Carlo Planning in Large POMDPs}},
url = {http://discovery.ucl.ac.uk/1347369/},
year = {2010}
}
@article{Caceres2014,
abstract = {Learning the right graph representation from noisy, multi- source data has garnered significant interest in recent years. A central tenet of this problem is relational learning. Here the objective is to incorporate the partial information each data source gives us in a way that captures the true under- lying relationships. To address this challenge, we present a general, boosting-inspired framework for combining weak evidence of entity associations into a robust similarity met- ric. We explore the extent to which different quality mea- surements yield graph representations that are suitable for community detection. We then present empirical results on both synthetic and real datasets demonstrating the utility of this framework. Our framework leads to suitable global graph representations from quality measurements local to each edge. Finally, we discuss future extensions and theoret- ical considerations of learning useful graph representations from weak feedback in general application settings.},
archivePrefix = {arXiv},
arxivId = {arXiv:1401.3258v1},
author = {Caceres, R and Carter, K and Kun, Jeremy},
eprint = {arXiv:1401.3258v1},
file = {:home/zach/Util/Papers/A Boosting Approach to Learning Graph Representations - Caceres, Carter, Kun - 2014.pdf:pdf},
journal = {arXiv preprint arXiv:1401.3258},
title = {{A Boosting Approach to Learning Graph Representations}},
url = {http://arxiv.org/abs/1401.3258},
year = {2014}
}
@article{LaViolette2009,
abstract = {We show how one can completely reconstruct even moderately optimized configurations of the Forest Fire model with relatively few observations. We discuss the relationship between the deep information from limited observations (DILO) to the robust-yet-fragile (RYF) property of the Forest Fire model and propose that DILO may be a general property of RYF complex systems. ?? 2009 Elsevier B.V. All rights reserved.},
author = {LaViolette, Randall a. and Glass, Kristin and Colbaugh, Richard},
doi = {10.1016/j.physa.2009.05.019},
file = {:home/zach/Util/Papers/Deep information from limited observation of robust yet fragile systems - LaViolette, Glass, Colbaugh - 2009.pdf:pdf},
issn = {03784371},
journal = {Physica A: Statistical Mechanics and its Applications},
keywords = {Complex systems,Deep information,Limited observations,Random systems,Robust yet fragile,Vulnerability},
number = {17},
pages = {3283--3287},
publisher = {Elsevier B.V.},
title = {{Deep information from limited observation of robust yet fragile systems}},
url = {http://dx.doi.org/10.1016/j.physa.2009.05.019},
volume = {388},
year = {2009}
}
@article{Araya-Lopez2010,
abstract = {Partially Observable Markov Decision Processes (POMDPs) model sequential decision-making problems under uncertainty and partial observability. Unfortunately, some problems cannot be modeled with state-dependent reward functions, e.g., problems whose objective explicitly implies reducing the uncertainty on the state. To that end, we introduce POMDPs, an extension of POMDPs where the reward function depends on the belief state. We show that, under the common assumption that is convex, the value function is also convex, what makes it possible to (1) approximate arbitrarily well with a piecewise linear and convex (PWLC) function, and (2) use state-of-the-art exact or approximate solving algorithms with limited changes.},
author = {Araya-L\'{o}pez, M and Buffet, O and Thomas, V},
file = {:home/zach/Util/Papers/A POMDP Extension with Belief-dependent Rewards. - Araya-L\'{o}pez, Buffet, Thomas - 2010.pdf:pdf},
isbn = {9781617823800},
journal = {Nips},
number = {i},
pages = {1--21},
title = {{A POMDP Extension with Belief-dependent Rewards.}},
url = {http://hal.archives-ouvertes.fr/docs/00/52/94/98/PDF/RR-7433.pdf$\backslash$npapers2://publication/uuid/1815F1A7-8427-480B-B234-BB6DFE7958A4$\backslash$nhttps://papers.nips.cc/paper/3971-a-pomdp-extension-with-belief-dependent-rewards.pdf},
year = {2010}
}
@article{Maiya2010,
abstract = {We propose a novel method, based on concepts from expander graphs, to sample communities in networks. We show that our sampling method, unlike previous techniques, produces subgraphs representative of community structure in the original network. These generated subgraphs may be viewed as stratified samples in that they consist of members from most or all communities in the network. Using samples produced by our method, we show that the problem of community detection may be recast into a case of statistical relational learning. We empirically evaluate our approach against several real-world datasets and demonstrate that our sampling method can effectively be used to infer and approximate community affiliation in the larger network.},
author = {Maiya, Arun S. and Berger-Wolf, Tanya Y.},
doi = {10.1145/1772690.1772762},
file = {:home/zach/Util/Papers/Sampling community structure - Maiya, Berger-Wolf - 2010.pdf:pdf},
isbn = {9781605587998},
journal = {Proceedings of the 19th international conference on World wide web - WWW '10},
keywords = {clustering,community detection,complex networks,graphs,sampling,social networks},
pages = {701--710},
title = {{Sampling community structure}},
url = {http://portal.acm.org/citation.cfm?doid=1772690.1772762},
year = {2010}
}
@article{Wu2013,
abstract = {A simple deterministic algorithm for community detection is provided by using two rounds of minimum spanning trees. By comparing the first round minimum spanning tree (1st-MST) with the second round spanning tree (2nd-MST) of the network, communities are detected and their overlapping nodes are also identified. To generate the two MSTs, a distance matrix is defined and computed from the adjacent matrix of the network. Compared with the resistance matrix or the communicability matrix used in community detection in the literature, the proposed distance matrix is very simple in computation. The proposed algorithm is tested on real world social networks, graphs which are failed by the modularity maximization, and the LFR benchmark graphs for community detection. ?? 2012 Elsevier B.V. All rights reserved.},
annote = {Just for detecting communities, not sampling},
author = {Wu, Jianshe and Li, Xiaoxiao and Jiao, Licheng and Wang, Xiaohua and Sun, Bo},
doi = {10.1016/j.physa.2013.01.015},
file = {:home/zach/Util/Papers/Minimum spanning trees for community detection - Wu et al. - 2013.pdf:pdf},
issn = {03784371},
journal = {Physica A: Statistical Mechanics and its Applications},
keywords = {Community structure,Complex network,Distance matrix,Minimum spanning tree},
number = {9},
pages = {2265--2277},
publisher = {Elsevier B.V.},
title = {{Minimum spanning trees for community detection}},
url = {http://dx.doi.org/10.1016/j.physa.2013.01.015},
volume = {392},
year = {2013}
}
@article{Colbaugh2010,
abstract = {Large, complex networks are ubiquitous in nature and society, and there is great interest in developing rigorous, scalable methods for identifying and characterizing their vulnerabilities. This paper presents an approach for analyzing the dynamics of complex networks in which the network of interest is first abstracted to a much simpler, but mathematically equivalent, representation, the required analysis is performed on the abstraction, and analytic conclusions are then mapped back to the original network and interpreted there. We begin by identifying a broad and important class of complex networks which admit vulnerability-preserving, finite state abstractions, and develop efficient algorithms for computing these abstractions. We then propose a vulnerability analysis methodology which combines these finite state abstractions with formal analytics from theoretical computer science to yield a comprehensive vulnerability analysis process for networks of realworld scale and complexity. The potential of the proposed approach is illustrated with a case study involving a realistic electric power grid model and also with brief discussions of biological and social network examples.},
archivePrefix = {arXiv},
arxivId = {1012.5990},
author = {Colbaugh, Richard and Glass, Kristin},
eprint = {1012.5990},
file = {:home/zach/Util/Papers/Vulnerability Analysis for Complex Networks Using Aggressive Abstraction - Colbaugh, Glass - 2010.pdf:pdf},
number = {October},
title = {{Vulnerability Analysis for Complex Networks Using Aggressive Abstraction}},
url = {http://arxiv.org/abs/1012.5990},
year = {2010}
}
@article{Bilgic2010,
abstract = {We introduce a novel active learning algorithm for classification of network data. In this setting, training instances are connected by a set of links to form a network, the labels of linked nodes are correlated, and the goal is to exploit these dependencies and accurately label the nodes. This problem arises in many domains, including social and biological network analysis and document classification, and there has been much recent interest in methods that collectively classify the nodes in the network. While in many cases labeled examples are expensive, often network information is available. We show how an active learning algorithm can take advantage of network structure. Our algorithm effectively exploits the links between instances and the interaction between the local and collective aspects of a classifier to improve the accuracy of learning from fewer labeled examples. We experiment with two real-world benchmark collective classification domains, and show that we are able to achieve extremely accurate results even when only a small fraction of the data is labeled. 1.},
author = {Bilgic, Mustafa and Getoor, Lise},
doi = {10.1016/j.tcs.2010.04.007},
file = {:home/zach/Util/Papers/Active Learning for Networked Data - Bilgic, Getoor - 2010.pdf:pdf},
isbn = {9781605589077},
journal = {Computer},
number = {29-30},
pages = {2712--2728},
title = {{Active Learning for Networked Data}},
url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.165.6227\&rep=rep1\&type=pdf},
volume = {411},
year = {2010}
}
@article{Soundarajan2014,
author = {Soundarajan, Sucheta and Eliassi-rad, Tina and Gallagher, Brian and Pinar, Ali},
file = {:home/zach/Util/Papers/Strategies for Probing Incomplete Graphs - Soundarajan et al. - 2014.pdf:pdf},
title = {{Strategies for Probing Incomplete Graphs}},
year = {2014}
}
@article{Yun2014,
abstract = {In this paper, we consider networks consisting of a finite number of non-overlapping communities. To extract these communities, the interaction between pairs of nodes may be sampled from a large available data set, which allows a given node pair to be sampled several times. When a node pair is sampled, the observed outcome is a binary random variable, equal to 1 if nodes interact and to 0 otherwise. The outcome is more likely to be positive if nodes belong to the same communities. For a given budget of node pair samples or observations, we wish to jointly design a sampling strategy (the sequence of sampled node pairs) and a clustering algorithm that recover the hidden communities with the highest possible accuracy. We consider both non-adaptive and adaptive sampling strategies, and for both classes of strategies, we derive fundamental performance limits satisfied by any sampling and clustering algorithm. In particular, we provide necessary conditions for the existence of algorithms recovering the communities accurately as the network size grows large. We also devise simple algorithms that accurately reconstruct the communities when this is at all possible, hence proving that the proposed necessary conditions for accurate community detection are also sufficient. The classical problem of community detection in the stochastic block model can be seen as a particular instance of the problems consider here. But our framework covers more general scenarios where the sequence of sampled node pairs can be designed in an adaptive manner. The paper provides new results for the stochastic block model, and extends the analysis to the case of adaptive sampling.},
archivePrefix = {arXiv},
arxivId = {1402.3072},
author = {Yun, Se-Young and Proutiere, Alexandre},
eprint = {1402.3072},
file = {:home/zach/Util/Papers/Community detection via random and adaptive sampling - Yun, Proutiere - 2014.pdf:pdf},
journal = {arXiv preprint},
pages = {1--39},
title = {{Community detection via random and adaptive sampling}},
url = {http://arxiv.org/abs/1402.3072},
year = {2014}
}
@inproceedings{Ho2015,
author = {Ho, Christopher and Kochenderfer, Mykel J. and Mehta, Vineet and Caceres, Rajmonda S.},
booktitle = {IEEE Conference on Decision and Control},
title = {{Control of Epidemics on Graph}},
year = {2015}
}
@article{Browne2012,
author = {Browne, CB and Powley, Edward},
file = {:home/zach/Util/Papers/A survey of monte carlo tree search methods - Browne, Powley - 2012.pdf:pdf},
journal = {IEEE Transactions on computational intelligence and ai in games},
number = {1},
pages = {1--43},
title = {{A survey of monte carlo tree search methods}},
url = {http://ieeexplore.ieee.org/xpls/abs\_all.jsp?arnumber=6145622},
volume = {4},
year = {2012}
}
@article{Seshadhri2014,
abstract = {Graphs are used to model interactions in a variety of contexts, and there is a growing need to quickly assess the structure of such graphs. Some of the most useful graph metrics are based on triangles, such as those measuring social cohesion. Despite the importance of these triadic measures, algorithms to compute them can be extremely expensive. We discuss the method of wedge sampling. This versatile technique allows for the fast and accurate approximation of various types of clustering coecients and triangle counts. Furthermore, these techniques are extensible to counting directed triangles in digraphs. Our methods come with provable and practical time-approximation tradeo s for all computations. We provide extensive results that show our methods are orders of magnitude faster than the state of the art, while providing nearly the accuracy of full enumeration.},
archivePrefix = {arXiv},
arxivId = {1309.3321},
author = {Seshadhri, C. and Pinar, Ali and Kolda, Tamara G.},
doi = {10.1002/sam.11224},
eprint = {1309.3321},
file = {:home/zach/Util/Papers/Wedge sampling for computing clustering coefficients and triangle counts on large graphs - Seshadhri, Pinar, Kolda - 2014.pdf:pdf},
issn = {19321872},
journal = {Statistical Analysis and Data Mining},
keywords = {Clustering coefficients,Directed triangles,Triangle characteristics,Triangle counting,Wedge sampling},
number = {4},
pages = {294--307},
title = {{Wedge sampling for computing clustering coefficients and triangle counts on large graphs}},
volume = {7},
year = {2014}
}
@article{Wang2013,
annote = {recognize importance of a},
author = {Wang, Xuezhi and Garnett, Roman and Schneider, Jeff},
doi = {10.1145/2487575.2487605},
file = {:home/zach/Util/Papers/Active search on graphs - Wang, Garnett, Schneider - 2013.pdf:pdf},
isbn = {9781450321747},
journal = {Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining - KDD '13},
keywords = {active learning,graph search},
pages = {731},
title = {{Active search on graphs}},
url = {http://dl.acm.org/citation.cfm?doid=2487575.2487605},
year = {2013}
}
@article{Newman2006,
abstract = {Many networks of interest in the sciences, including social networks, computer networks, and metabolic and regulatory networks, are found to divide naturally into communities or modules. The problem of detecting and characterizing this community structure is one of the outstanding issues in the study of networked systems. One highly effective approach is the optimization of the quality function known as "modularity" over the possible divisions of a network. Here I show that the modularity can be expressed in terms of the eigenvectors of a characteristic matrix for the network, which I call the modularity matrix, and that this expression leads to a spectral algorithm for community detection that returns results of demonstrably higher quality than competing methods in shorter running times. I illustrate the method with applications to several published network data sets.},
archivePrefix = {arXiv},
arxivId = {physics/0602124},
author = {Newman, Mej},
doi = {10.1073/pnas.0601602103},
eprint = {0602124},
file = {:home/zach/Util/Papers/Modularity and community structure in networks - Newman - 2006.pdf:pdf},
isbn = {0027-8424 (Print)$\backslash$r0027-8424 (Linking)},
issn = {0027-8424},
journal = {Proceedings of the National Academy of \ldots},
number = {23},
pages = {8577--82},
pmid = {16723398},
primaryClass = {physics},
title = {{Modularity and community structure in networks}},
url = {http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=1482622\&tool=pmcentrez\&rendertype=abstract$\backslash$nhttp://www.pnas.org/content/103/23/8577.short},
volume = {103},
year = {2006}
}
@article{Maiya2010a,
abstract = {In this work, we investigate the use of online or “crawling” algorithms to sample large social networks in order to determine the most influential or important individuals within the network (by varying definitions of network centrality). We describe a novel sampling technique based on concepts from expander graphs. We empirically evaluate this method in addition to other online sampling strategies on several real-world social networks. We find that, by sampling nodes to maximize the expansion of the sample, we are able to approximate the set of most influential individuals across multiple measures of centrality.},
author = {Maiya, Arun S. and Berger-Wolf, Tanya Y.},
doi = {10.1007/978-3-642-13657-3\_12},
file = {:home/zach/Util/Papers/Online sampling of high centrality individuals in social networks - Maiya, Berger-Wolf - 2010.pdf:pdf},
isbn = {3642136567},
issn = {03029743},
journal = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
number = {PART 1},
pages = {91--98},
title = {{Online sampling of high centrality individuals in social networks}},
volume = {6118 LNAI},
year = {2010}
}
@article{Blondel2008,
abstract = {We propose a simple method to extract the community structure of large networks. Our method is a heuristic method that is based on modularity optimization. It is shown to outperform all other known community detection method in terms of computation time. Moreover, the quality of the communities detected is very good, as measured by the so-called modularity. This is shown first by identifying language communities in a Belgian mobile phone network of 2.6 million customers and by analyzing a web graph of 118 million nodes and more than one billion links. The accuracy of our algorithm is also verified on ad-hoc modular networks. .},
archivePrefix = {arXiv},
arxivId = {0803.0476},
author = {Blondel, Vincent D. and Guillaume, Jean-Loup and Lambiotte, Renaud and Lefebvre, Etienne},
doi = {10.1088/1742-5468/2008/10/P10008},
eprint = {0803.0476},
file = {:home/zach/Util/Papers/Fast unfolding of communities in large networks - Blondel et al. - 2008.pdf:pdf},
isbn = {1742-5468},
issn = {1742-5468},
pages = {6},
pmid = {260529900010},
title = {{Fast unfolding of communities in large networks}},
url = {http://arxiv.org/abs/0803.0476},
volume = {10008},
year = {2008}
}
@article{Mihaylova2003,
abstract = {This work presents a comparison of decision making criteria and optimization methods for active sensing in robotics. Active sensing incorporates the following aspects: (i ) where to position sensors, and (ii ) how to make decisions for next actions, in order to maximize information gain and minimize costs. We concentrate on the second aspect: “Where should the robot move at the next time step?”. Pros and cons of the most often used statistical decision making strategies are discussed. Simulation results from a new multisine approach for active sensing of a nonholonomic mobile robot are given.},
author = {Mihaylova, L and Lefebvre, T and Bryunincks, H and {De Schutter}, J},
doi = {10.1007/3-540-36487-0\_35},
file = {:home/zach/Util/Papers/A Comparison of Decision Making Criteria and Optimization Methods for Active Robotic Sensing. - Mihaylova et al. - 2003.pdf:pdf},
issn = {03029743},
keywords = {QA75 Electronic computers. Computer science},
pages = {316--324},
title = {{A Comparison of Decision Making Criteria and Optimization Methods for Active Robotic Sensing.}},
url = {http://www.springerlink.com/content/wltdv72yhv4w5kpb/?p=91d1803b22614e23a79806d39f884ace\&pi=9},
year = {2003}
}
@article{Wang1987,
author = {Wang, Yuchung J and Wong, George Y},
doi = {10.1080/01621459.1987.10478385},
journal = {Journal of the American Statistical Association},
number = {397},
pages = {8--19},
title = {{Stochastic Blockmodels for Directed Graphs}},
url = {http://www.tandfonline.com/doi/abs/10.1080/01621459.1987.10478385},
volume = {82},
year = {1987}
}
@article{DJW-SHS:98,
author = {Watts, D J and Strogatz, S H},
file = {:home/zach/Util/Papers/Collective dynamics of `small-world' networks - Watts, Strogatz - 1998.pdf:pdf},
journal = {Nature},
pages = {440--442},
title = {{Collective dynamics of `small-world' networks}},
volume = {393},
year = {1998}
}
@article{Leskovec2006,
abstract = {Given a huge real graph, how can we derive a representative sample? There are many known algorithms to compute interesting measures (shortest paths, centrality, betweenness, etc.), but several of them become impractical for large graphs. Thus graph sampling is essential.The natural questions to ask are (a) which sampling method to use, (b) how small can the sample size be, and (c) how to scale up the measurements of the sample (e.g., the diameter), to get estimates for the large graph. The deeper, underlying question is subtle: how do we measure success?.We answer the above questions, and test our answers by thorough experiments on several, diverse datasets, spanning thousands nodes and edges. We consider several sampling methods, propose novel methods to check the goodness of sampling, and develop a set of scaling laws that describe relations between the properties of the original and the sample.In addition to the theoretical contributions, the practical conclusions from our work are: Sampling strategies based on edge selection do not perform well; simple uniform random node selection performs surprisingly well. Overall, best performing methods are the ones based on random-walks and "forest fire"; they match very accurately both static as well as evolutionary graph patterns, with sample sizes down to about 15\% of the original graph.},
author = {Leskovec, Jure and Faloutsos, Christos},
doi = {10.1145/1150402.1150479},
file = {:home/zach/Util/Papers/Sampling from large graphs - Leskovec, Faloutsos - 2006.pdf:pdf},
isbn = {1595933395},
journal = {Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining},
keywords = {graph mining,graph sampling,scaling laws},
pages = {631--636},
title = {{Sampling from large graphs}},
url = {http://dl.acm.org/citation.cfm?id=1150479},
year = {2006}
}
@inproceedings{Liu2015,
author = {Liu, Jialu and Han, Jiawei},
booktitle = {Proceedings of the Eighth ACM International Conference on Web Search and Data Mining},
file = {:home/zach/Util/Papers/On Integrating Network and Community Discovery - Liu, Han - 2015.pdf:pdf},
isbn = {9781450333177},
keywords = {community detection,network discovery},
pages = {117--126},
title = {{On Integrating Network and Community Discovery}},
year = {2015}
}
@article{Fortunato2010,
abstract = {The modern science of networks has brought significant advances to our understanding of complex systems. One of the most relevant features of graphs representing real systems is community structure, or clustering, i.e. the organization of vertices in clusters, with many edges joining vertices of the same cluster and comparatively few edges joining vertices of different clusters. Such clusters, or communities, can be considered as fairly independent compartments of a graph, playing a similar role like, e.g., the tissues or the organs in the human body. Detecting communities is of great importance in sociology, biology and computer science, disciplines where systems are often represented as graphs. This problem is very hard and not yet satisfactorily solved, despite the huge effort of a large interdisciplinary community of scientists working on it over the past few years. We will attempt a thorough exposition of the topic, from the definition of the main elements of the problem, to the presentation of most methods developed, with a special focus on techniques designed by statistical physicists, from the discussion of crucial issues like the significance of clustering and how methods should be tested and compared against each other, to the description of applications to real networks. ?? 2009 Elsevier B.V.},
archivePrefix = {arXiv},
arxivId = {0906.0612},
author = {Fortunato, Santo},
doi = {10.1016/j.physrep.2009.11.002},
eprint = {0906.0612},
file = {:home/zach/Util/Papers/Community detection in graphs - Fortunato - 2010.pdf:pdf},
isbn = {0370-1573},
issn = {03701573},
journal = {Physics Reports},
keywords = {Clusters,Graphs,Statistical physics},
number = {3-5},
pages = {75--174},
pmid = {22166104},
publisher = {Elsevier B.V.},
title = {{Community detection in graphs}},
url = {http://dx.doi.org/10.1016/j.physrep.2009.11.002},
volume = {486},
year = {2010}
}
@article{Iii2012,
author = {Iii, Jj Pfeiffer and Neville, J and Bennett, Pn},
file = {:home/zach/Util/Papers/Active sampling of networks - Iii, Neville, Bennett - 2012.pdf:pdf},
journal = {Proceedings of the Workshop on Mining and Learning with Graphs (MLG-2012)},
title = {{Active sampling of networks}},
url = {http://131.107.65.14/en-us/um/people/pauben/papers/pfeiffer-et-al-mlg-icml-2012.pdf},
year = {2012}
}
@book{Kochenderfer2015,
author = {Kochenderfer, Mykel J.},
publisher = {MIT Press},
title = {{Decision Making Under Uncertainty: Theory and Practice}},
year = {2015}
}
@article{Danon2005,
abstract = {We compare recent approaches to community structure identification in terms of sensitivity and computational cost. The recently proposed modularity measure is revisited and the performance of the methods as applied to ad hoc networks with known community structure, is compared. We find that the most accurate methods tend to be more computationally expensive, and that both aspects need to be considered when choosing a method for practical purposes. The work is intended as an introduction as well as a proposal for a standard benchmark test of community detection methods.},
archivePrefix = {arXiv},
arxivId = {cond-mat/0505245},
author = {Danon, Leon and Duch, Jordi and Diaz-Guilera, Albert and Arenas, Alex},
doi = {10.1088/1742-5468/2005/09/P09008},
eprint = {0505245},
file = {:home/zach/Util/Papers/Comparing community structure identification - Danon et al. - 2005.pdf:pdf},
pages = {10},
primaryClass = {cond-mat},
title = {{Comparing community structure identification}},
url = {http://arxiv.org/abs/cond-mat/0505245},
volume = {09008},
year = {2005}
}
@article{Schapire1990,
abstract = {The problem of improving the accuracy of a hypothesis output by a
learning algorithm in the distribution-free learning model is
considered. A concept class is learnable (or strongly learnable) if,
given access to a source of examples from the unknown concept, the
learner with high probability is able to output a hypothesis that is
correct on all but an arbitrarily small fraction of the instances. The
concept class is weakly learnable if the learner can produce a
hypothesis that forms only slightly better than random guessing. It is
shown that these two notions of learnability are equivalent. An explicit
method is described for directly converting a weak learning algorithm
into one that achieves arbitrarily high accuracy. This construction may
have practical applications as a tool for efficiently converting a
mediocre learning algorithm into one that performs extremely well. In
addition, the construction has some interesting theoretical consequences
},
author = {Schapire, Robert E.},
doi = {10.1007/BF00116037},
file = {:home/zach/Util/Papers/The strength of weak learnability - Schapire - 1990.pdf:pdf},
isbn = {0-8186-1982-1},
issn = {08856125},
journal = {Machine Learning},
keywords = {Machine learning,PAC learning,learnability theory,learning from examples,polynomial-time identification},
number = {2},
pages = {197--227},
title = {{The strength of weak learnability}},
volume = {5},
year = {1990}
}


text:
require gst-plugins.inc

PR = "${INC_PR}.1"

DEPENDS += "gst-plugins-base mpeg2dec libsidplay"

SRC_URI += "\
  file://gstmad_16bit.patch \
  file://gstsid_autofoo_HACK.patch \
"
SRC_URI[archive.md5sum] = "989e1b0fab010f73f76912f70ec5f62a"
SRC_URI[archive.sha256sum] = "d7fc7636001e78736540c628ad889888cb85ea722f08d1c6813b16682dd9c09c"

python() {
	# Don't build, if we are building an ENTERPRISE distro
	enterprise = bb.data.getVar("ENTERPRISE_DISTRO", d, 1)
	if enterprise == "1":
		raise bb.parse.SkipPackage("gst-plugins-ugly will only build if ENTERPRISE_DISTRO != 1")
}

PACKAGES_DYNAMIC = "\
gst-plugin-a52dec* \
gst-plugin-asf* \
gst-plugin-cdio* \
gst-plugin-dvdlpcmdec* \
gst-plugin-dvdread* \
gst-plugin-dvdsub* \
gst-plugin-iec958* \
gst-plugin-lame* \
gst-plugin-mad* \
gst-plugin-mpeg2dec* \
gst-plugin-mpegaudioparse* \
gst-plugin-mpegstream* \
gst-plugin-rmdemux* \
gst-plugin-sid* \
gst-plugin-x264* \
"

license: MIT

repository: balister/openembedded

license_type: permissive

repo_name: balister/openembedded

branch_name: refs/heads/master

extension: bb


text:
@article{mccaffrey_characterization_2015,
 abstract = {As interest in marine renewable energy increases, observations are crucial for understanding the environments that prospective turbines will encounter. Data from an acoustic Doppler velocimeter in Puget Sound, WA are used to perform a detailed characterization of the turbulent ﬂow encountered by a turbine in a tidal strait. Metrics such as turbulence intensity, structure functions, probability density functions, intermittency, coherent turbulence kinetic energy, anisotropy invariants, and a new scalar measure of anisotropy are used to characterize the turbulence. The results indicate that the scalar anisotropy magnitude can be used to identify and parameterize coherent, turbulent events in the ﬂow. An analysis of the anisotropy characteristics leads to a physical description of turbulent stresses as being primarily one- or two-dimensional, in contrast to isotropic, three-dimensional turbulence. A new measure of the anisotropy magnitude is introduced to quantify the level of anisotropic, coherent turbulence in a coordinate-independent way. These diagnostics and results will be useful for improved realism in modeling the performance and loading of turbines in realistic ocean environments.},
 author = {McCaffrey, Katherine and Fox-Kemper, Baylor and Hamlington, Peter E. and Thomson, Jim},
 doi = {10.1016/j.renene.2014.11.063},
 file = {McCaffrey et al. - 2015 - Characterization of turbulence anisotropy, coheren.pdf:/Users/peterh/Zotero/storage/NC8ZQMI5/McCaffrey et al. - 2015 - Characterization of turbulence anisotropy, coheren.pdf:application/pdf},
 issn = {09601481},
 journal = {Renewable Energy},
 language = {en},
 month = {April},
 pages = {441--453},
 shorttitle = {Characterization of turbulence anisotropy, coherence, and intermittency at a prospective tidal energy site},
 title = {Characterization of turbulence anisotropy, coherence, and intermittency at a prospective tidal energy site: Observational data analysis},
 url = {https://linkinghub.elsevier.com/retrieve/pii/S0960148114007939},
 urldate = {2020-06-27},
 volume = {76},
 year = {2015}
}

repository: kilojoules/website

repo_name: kilojoules/website

gha_license_id: MIT

extension: bib


text:
require u-boot-gumstix.inc

PV = "2016.01"

COMPATIBLE_MACHINE = "poblano"

# v2016.01 = fa85e826c16b9ce1ad302a57e9c4b24db0d8b930
SRCREV = "fa85e826c16b9ce1ad302a57e9c4b24db0d8b930"
SRC_URI = " \
    git://git.denx.de/u-boot.git;protocol=git;branch=master \
    file://0001-am437x-poblano-Add-a-new-board.patch \
"

repository: alex-wells/meta-gumstix

repo_name: alex-wells/meta-gumstix

branch_name: refs/heads/fido


text:
SUMMARY ="openZwave recipe for yocto"

DESCRIPTION = "openzwave allow to control device that use zwave protocole for home automation ..."

AUTHOR = "modjo.buggy22@orange.fr"

DEPENDS = "\
    eudev  \
    automake     \
"

S = "${WORKDIR}/git"

LICENSE = "Apache-2.0 & GPLv2 & LGPLv2+ "

LIC_FILES_CHKSUM = " \
    file://license/Apache-License-2.0.txt;md5=5dbc052533cb6e0e47352828d40f42f2 \
    file://license/gpl.txt;md5=1c775619c98e9b11e58da29617fc9c9f \
    file://license/lgpl.txt;md5=7be289db0a5cd2c8acf72a8cbd0c15df \
"

GIT_URL = "git://github.com/OpenZWave/open-zwave.git"
SRC_URI = "${GIT_URL};branch=master;protocol=git"

SRCREV = "67f32fbdc018544a07635b5c8ed202c7b1de62c9"

do_configure[noexec] = "1"

do_compile() {
    export PREFIX="${D}${prefix}"
    export pkgconfigdir="${PKG_CONFIG_DIR}"
    export instlibdir="${D}${prefix}${base_libdir}"
    make BITBAKE_ENV=1

}

do_install () {
    export PREFIX="${D}${prefix}"
    export pkgconfigdir="${PKG_CONFIG_DIR}"
    export instlibdir="${D}${prefix}${base_libdir}"
    make BITBAKE_ENV=1 install
}

FILES_${PN} += "${prefix}${sysconfdir}/${PN}/*"


text:
SUMMARY = "A simple daemon to allow session software to update firmware"
LICENSE = "LGPL-2.1+"
LIC_FILES_CHKSUM = "file://COPYING;md5=4fbd65380cdd255951079008b364516c"

DEPENDS = "glib-2.0 libxmlb json-glib sqlite3 libjcat gcab vala-native"

SRC_URI = "https://github.com/${BPN}/${BPN}/releases/download/1.7.1/${BP}.tar.xz \
           file://run-ptest \
           file://no-bash.patch \
           file://io.patch"
SRC_URI[sha256sum] = "ae56ceb44b786f21f54d133ac70bc5d9cb8cd4bda0167339c669a228da67fa3c"

UPSTREAM_CHECK_URI = "https://github.com/${BPN}/${BPN}/releases"

# Machine-specific as we examine MACHINE_FEATURES to decide whether to build the UEFI plugins
PACKAGE_ARCH = "${MACHINE_ARCH}"

inherit meson vala gobject-introspection systemd bash-completion pkgconfig gi-docgen ptest manpages

GIDOCGEN_MESON_OPTION = 'docs'
GIDOCGEN_MESON_ENABLE_FLAG = 'docgen'
GIDOCGEN_MESON_DISABLE_FLAG = 'none'

PACKAGECONFIG ??= "curl gnutls gudev gusb lzma \
                   ${@bb.utils.filter('DISTRO_FEATURES', 'polkit systemd', d)} \
                   ${@bb.utils.contains('MACHINE_FEATURES', 'efi', 'plugin_uefi_capsule plugin_uefi_pk', '', d)} \
                   ${@bb.utils.contains('PTEST_ENABLED', '1', 'tests plugin_dummy', '', d)} \
                   plugin_altos \
                   plugin_amt \
                   plugin_emmc \
                   plugin_fastboot \
                   plugin_flashrom \
                   plugin_intel_spi \
                   plugin_logitech_bulkcontroller \
                   plugin_modem_manager \
                   plugin_msr \
                   plugin_nvme \
                   plugin_parade_lspcon \
                   plugin_platform_integrity \
                   plugin_realtek_mst \
                   plugin_redfish \
                   plugin_synaptics_mst \
                   plugin_synaptics_rmi \
                   plugin_thunderbolt"

PACKAGECONFIG[bluez] = "-Dbluez=true,-Dbluez=false"
PACKAGECONFIG[consolekit] = "-Dconsolekit=true,-Dconsolekit=false,consolekit"
PACKAGECONFIG[curl] = "-Dcurl=true,-Dcurl=false,curl"
PACKAGECONFIG[firmware-packager] = "-Dfirmware-packager=true,-Dfirmware-packager=false"
PACKAGECONFIG[gnutls] = "-Dgnutls=true,-Dgnutls=false,gnutls"
PACKAGECONFIG[gudev] = "-Dgudev=true,-Dgudev=false,libgudev"
PACKAGECONFIG[gusb] = "-Dgusb=true,-Dgusb=false,libgusb"
PACKAGECONFIG[libarchive] = "-Dlibarchive=true,-Dlibarchive=false,libarchive"
PACKAGECONFIG[lzma] = "-Dlzma=true,-Dlzma=false,xz"
PACKAGECONFIG[manpages] = "-Dman=true,-Dman=false"
PACKAGECONFIG[polkit] = "-Dpolkit=true,-Dpolkit=false,polkit"
PACKAGECONFIG[systemd] = "-Dsystemd=true,-Dsystemd=false,systemd"
PACKAGECONFIG[tests] = "-Dtests=true,-Dtests=false,gcab-native"

# TODO plugins-all meta-option that expands to all plugin_*?
PACKAGECONFIG[plugin_altos] = "-Dplugin_altos=true,-Dplugin_altos=false,elfutils"
PACKAGECONFIG[plugin_amt] = "-Dplugin_amt=true,-Dplugin_amt=false"
PACKAGECONFIG[plugin_dell] = "-Dplugin_dell=true,-Dplugin_dell=false,libsmbios"
PACKAGECONFIG[plugin_dummy] = "-Dplugin_dummy=true,-Dplugin_dummy=false"
PACKAGECONFIG[plugin_emmc] = "-Dplugin_emmc=true,-Dplugin_emmc=false"
PACKAGECONFIG[plugin_fastboot] = "-Dplugin_fastboot=true,-Dplugin_fastboot=false"
PACKAGECONFIG[plugin_flashrom] = "-Dplugin_flashrom=true,-Dplugin_flashrom=false,flashrom"
PACKAGECONFIG[plugin_intel_spi] = "-Dplugin_intel_spi=true,-Dplugin_intel_spi=false"
PACKAGECONFIG[plugin_logitech_bulkcontroller] = "-Dplugin_logitech_bulkcontroller=true,-Dplugin_logitech_bulkcontroller=false,protobuf-c-native protobuf-c"
PACKAGECONFIG[plugin_modem_manager] = "-Dplugin_modem_manager=true,-Dplugin_modem_manager=false,libqmi modemmanager"
PACKAGECONFIG[plugin_msr] = "-Dplugin_msr=true,-Dplugin_msr=false,cpuid"
PACKAGECONFIG[plugin_nvme] = "-Dplugin_nvme=true,-Dplugin_nvme=false"
PACKAGECONFIG[plugin_parade_lspcon] = "-Dplugin_parade_lspcon=true,-Dplugin_parade_lspcon=false"
PACKAGECONFIG[plugin_platform_integrity] = "-Dplugin_platform_integrity=true,-Dplugin_platform_integrity=false"
PACKAGECONFIG[plugin_realtek_mst] = "-Dplugin_realtek_mst=true,-Dplugin_realtek_mst=false"
PACKAGECONFIG[plugin_redfish] = "-Dplugin_redfish=true,-Dplugin_redfish=false"
PACKAGECONFIG[plugin_synaptics_mst] = "-Dplugin_synaptics_mst=true,-Dplugin_synaptics_mst=false"
PACKAGECONFIG[plugin_synaptics_rmi] = "-Dplugin_synaptics_rmi=true,-Dplugin_synaptics_rmi=false"
PACKAGECONFIG[plugin_thunderbolt] = "-Dplugin_thunderbolt=true,-Dplugin_thunderbolt=false"
PACKAGECONFIG[plugin_tpm] = "-Dplugin_tpm=true,-Dplugin_tpm=false,tpm2-tss"
# Turn off the capsule splash as it needs G-I at buildtime, which isn't currently supported
PACKAGECONFIG[plugin_uefi_capsule] = "-Dplugin_uefi_capsule=true -Dplugin_uefi_capsule_splash=false,-Dplugin_uefi_capsule=false,efivar fwupd-efi"
PACKAGECONFIG[plugin_uefi_pk] = "-Dplugin_uefi_pk=true,-Dplugin_uefi_pk=false"

# Always disable these plugins on non-x86 platforms as they don't compile
DISABLE_NON_X86 = "plugin_msr plugin_intel_spi"
DISABLE_NON_X86:x86 = ""
DISABLE_NON_X86:x86-64 = ""
PACKAGECONFIG:remove = "${DISABLE_NON_X86}"

FILES:${PN} += "${libdir}/fwupd-plugins-* \
                ${systemd_unitdir} \
                ${datadir}/fish \
                ${datadir}/metainfo \
                ${datadir}/icons \
                ${datadir}/dbus-1 \
                ${datadir}/polkit-1 \
                ${nonarch_libdir}/modules-load.d"

FILES:${PN}-ptest += "${libexecdir}/installed-tests/ \
                      ${datadir}/installed-tests/"
RDEPENDS:${PN}-ptest += "gnome-desktop-testing"

repository: pmod/meta-openembedded

repo_name: pmod/meta-openembedded


text:
@article{RN1221,
 author = {Cheema, M. I. and Khan, U. A. and Armani, A. M. and Kirk, A. G.},
 doi = {10.1364/Oe.21.022817},
 issn = {1094-4087},
 journal = {Optics Express},
 number = {19},
 pages = {22817-22828},
 title = {Towards more accurate microcavity sensors: maximum likelihood estimation applied to a combination of quality factor and wavelength shifts},
 type = {Journal Article},
 url = {<Go to ISI>://WOS:000325547200103},
 volume = {21},
 year = {2013}
}

repository: andrewgkirk/website

repo_name: andrewgkirk/website

gha_language: Jupyter Notebook


text:
package core

func uniqStrs(in []string) (out []string) {
	tab := make(map[string]struct{}) // empty struct because it's the smallest possible value
	for _, str := range in {
		if _, ok := tab[str]; !ok {
			tab[str] = struct{}{}
			out = append(out, str)
		}
	}
	return out
}

repository: linearregression/supergiant

repo_name: linearregression/supergiant

extension: go


text:
DESCRIPTION = "The Gumstix XFCE image.  This provides simple desktop \
environment using X11."
LICENSE = "MIT"

IMAGE_FEATURES += "x11-base"

require gumstix-console-image.bb

IMAGE_INSTALL += " \
    gnome-bluetooth \
    man \
    man-pages \
    network-manager-applet \
    packagegroup-xfce-extended \
    packagegroup-xfce-multimedia \
    chromium-x11 \
"

# Network Manager manages WPA supplicant---we don't need an interface-specific
# systemd service in this case.
zap_wlan0_wpa() {
    rm -f ${IMAGE_ROOTFS}/etc/systemd/system/multi-user.target.wants/wpa_supplicant@wlan0.service
}

ROOTFS_POSTPROCESS_COMMAND =+ "zap_wlan0_wpa;"

repository: gumstix/meta-gumstix-extras

repo_name: gumstix/meta-gumstix-extras

branch_name: refs/heads/warrior

gha_language: C


text:
import React from 'react';
import { Link } from 'react-router-dom';
import { Button, Hidden } from '@material-ui/core';
import { makeStyles } from '@material-ui/styles';
import { LOGIN_PATH, SIGNUP_PATH, COMPANY_PATH } from 'constants/paths';

const useStyles = makeStyles({
  button: {
    textTransform: 'capitalize',
    color: 'white',
    textDecoration: 'none',
    alignSelf: 'center'
  },
  mobileButton: {
    fontSize: '2.5vw',
    textTransform: 'capitalize',
    color: 'white',
    textDecoration: 'none',
    alignSelf: 'center'
  }
});

function LoginMenu() {
  const classes = useStyles();
  return (
    <>
      <Hidden mdUp>
        <Button className={classes.mobileButton} component={Link} to={COMPANY_PATH}>
          For Companies
        </Button>
        <Button className={classes.mobileButton} component={Link} to={SIGNUP_PATH}>
          Sign Up
        </Button>
        <Button className={classes.mobileButton} component={Link} to={LOGIN_PATH}>
          Login
        </Button>
      </Hidden>
      <Hidden smDown>
        <Button className={classes.button} component={Link} to={COMPANY_PATH}>
          For Companies
        </Button>
        <Button className={classes.button} component={Link} to={SIGNUP_PATH}>
          Sign Up
        </Button>
        <Button className={classes.button} component={Link} to={LOGIN_PATH}>
          Login
        </Button>
      </Hidden>
    </>
  );
}

export default LoginMenu;

repository: quangbestdev/react-job-onboarding

repo_name: quangbestdev/react-job-onboarding

extension: js


text:
// Copyright (c) 2021 AccelByte Inc. All Rights Reserved.
// This is licensed software from AccelByte Inc, for limitations
// and restrictions contact your company contract manager.

// Code generated; DO NOT EDIT.

package roles

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"strings"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"

	"github.com/AccelByte/accelbyte-go-sdk/iam-sdk/pkg/iamclientmodels"
)

// AdminAddRoleManagersV3Reader is a Reader for the AdminAddRoleManagersV3 structure.
type AdminAddRoleManagersV3Reader struct {
	formats strfmt.Registry
}

// ReadResponse reads a server response into the received o.
func (o *AdminAddRoleManagersV3Reader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
	switch response.Code() {
	case 204:
		result := NewAdminAddRoleManagersV3NoContent()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 400:
		result := NewAdminAddRoleManagersV3BadRequest()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 401:
		result := NewAdminAddRoleManagersV3Unauthorized()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 403:
		result := NewAdminAddRoleManagersV3Forbidden()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 404:
		result := NewAdminAddRoleManagersV3NotFound()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 409:
		result := NewAdminAddRoleManagersV3Conflict()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil

	default:
		data, err := ioutil.ReadAll(response.Body())
		if err != nil {
			return nil, err
		}

		return nil, fmt.Errorf("Requested POST /iam/v3/admin/roles/{roleId}/managers returns an error %d: %s", response.Code(), string(data))
	}
}

// NewAdminAddRoleManagersV3NoContent creates a AdminAddRoleManagersV3NoContent with default headers values
func NewAdminAddRoleManagersV3NoContent() *AdminAddRoleManagersV3NoContent {
	return &AdminAddRoleManagersV3NoContent{}
}

/*AdminAddRoleManagersV3NoContent handles this case with default header values.

  Operation succeeded
*/
type AdminAddRoleManagersV3NoContent struct {
}

func (o *AdminAddRoleManagersV3NoContent) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3NoContent ", 204)
}

func (o *AdminAddRoleManagersV3NoContent) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	return nil
}

// NewAdminAddRoleManagersV3BadRequest creates a AdminAddRoleManagersV3BadRequest with default headers values
func NewAdminAddRoleManagersV3BadRequest() *AdminAddRoleManagersV3BadRequest {
	return &AdminAddRoleManagersV3BadRequest{}
}

/*AdminAddRoleManagersV3BadRequest handles this case with default header values.

errorCode	errorMessage

20002	validation error

20019	unable to parse request body

*/
type AdminAddRoleManagersV3BadRequest struct {
	Payload *iamclientmodels.RestErrorResponse
}

func (o *AdminAddRoleManagersV3BadRequest) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3BadRequest  %+v", 400, o.ToJSONString())
}

func (o *AdminAddRoleManagersV3BadRequest) ToJSONString() string {
	if o.Payload == nil {
		return "{}"
	}

	b, err := json.Marshal(o.Payload)
	if err != nil {
		fmt.Println(err)

		return fmt.Sprintf("Failed to marshal the payload: %+v", o.Payload)
	}

	return fmt.Sprintf("%+v", string(b))
}

func (o *AdminAddRoleManagersV3BadRequest) GetPayload() *iamclientmodels.RestErrorResponse {
	return o.Payload
}

func (o *AdminAddRoleManagersV3BadRequest) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	o.Payload = new(iamclientmodels.RestErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewAdminAddRoleManagersV3Unauthorized creates a AdminAddRoleManagersV3Unauthorized with default headers values
func NewAdminAddRoleManagersV3Unauthorized() *AdminAddRoleManagersV3Unauthorized {
	return &AdminAddRoleManagersV3Unauthorized{}
}

/*AdminAddRoleManagersV3Unauthorized handles this case with default header values.

errorCode	errorMessage

20001	unauthorized access

*/
type AdminAddRoleManagersV3Unauthorized struct {
	Payload *iamclientmodels.RestErrorResponse
}

func (o *AdminAddRoleManagersV3Unauthorized) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3Unauthorized  %+v", 401, o.ToJSONString())
}

func (o *AdminAddRoleManagersV3Unauthorized) ToJSONString() string {
	if o.Payload == nil {
		return "{}"
	}

	b, err := json.Marshal(o.Payload)
	if err != nil {
		fmt.Println(err)

		return fmt.Sprintf("Failed to marshal the payload: %+v", o.Payload)
	}

	return fmt.Sprintf("%+v", string(b))
}

func (o *AdminAddRoleManagersV3Unauthorized) GetPayload() *iamclientmodels.RestErrorResponse {
	return o.Payload
}

func (o *AdminAddRoleManagersV3Unauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	o.Payload = new(iamclientmodels.RestErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewAdminAddRoleManagersV3Forbidden creates a AdminAddRoleManagersV3Forbidden with default headers values
func NewAdminAddRoleManagersV3Forbidden() *AdminAddRoleManagersV3Forbidden {
	return &AdminAddRoleManagersV3Forbidden{}
}

/*AdminAddRoleManagersV3Forbidden handles this case with default header values.

errorCode	errorMessage

20013	insufficient permissions

*/
type AdminAddRoleManagersV3Forbidden struct {
	Payload *iamclientmodels.RestErrorResponse
}

func (o *AdminAddRoleManagersV3Forbidden) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3Forbidden  %+v", 403, o.ToJSONString())
}

func (o *AdminAddRoleManagersV3Forbidden) ToJSONString() string {
	if o.Payload == nil {
		return "{}"
	}

	b, err := json.Marshal(o.Payload)
	if err != nil {
		fmt.Println(err)

		return fmt.Sprintf("Failed to marshal the payload: %+v", o.Payload)
	}

	return fmt.Sprintf("%+v", string(b))
}

func (o *AdminAddRoleManagersV3Forbidden) GetPayload() *iamclientmodels.RestErrorResponse {
	return o.Payload
}

func (o *AdminAddRoleManagersV3Forbidden) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	o.Payload = new(iamclientmodels.RestErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewAdminAddRoleManagersV3NotFound creates a AdminAddRoleManagersV3NotFound with default headers values
func NewAdminAddRoleManagersV3NotFound() *AdminAddRoleManagersV3NotFound {
	return &AdminAddRoleManagersV3NotFound{}
}

/*AdminAddRoleManagersV3NotFound handles this case with default header values.

errorCode	errorMessage

10456	role not found

*/
type AdminAddRoleManagersV3NotFound struct {
	Payload *iamclientmodels.RestErrorResponse
}

func (o *AdminAddRoleManagersV3NotFound) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3NotFound  %+v", 404, o.ToJSONString())
}

func (o *AdminAddRoleManagersV3NotFound) ToJSONString() string {
	if o.Payload == nil {
		return "{}"
	}

	b, err := json.Marshal(o.Payload)
	if err != nil {
		fmt.Println(err)

		return fmt.Sprintf("Failed to marshal the payload: %+v", o.Payload)
	}

	return fmt.Sprintf("%+v", string(b))
}

func (o *AdminAddRoleManagersV3NotFound) GetPayload() *iamclientmodels.RestErrorResponse {
	return o.Payload
}

func (o *AdminAddRoleManagersV3NotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	o.Payload = new(iamclientmodels.RestErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewAdminAddRoleManagersV3Conflict creates a AdminAddRoleManagersV3Conflict with default headers values
func NewAdminAddRoleManagersV3Conflict() *AdminAddRoleManagersV3Conflict {
	return &AdminAddRoleManagersV3Conflict{}
}

/*AdminAddRoleManagersV3Conflict handles this case with default header values.

errorCode	errorMessage

10468	role manager exist

*/
type AdminAddRoleManagersV3Conflict struct {
	Payload *iamclientmodels.RestErrorResponse
}

func (o *AdminAddRoleManagersV3Conflict) Error() string {
	return fmt.Sprintf("[POST /iam/v3/admin/roles/{roleId}/managers][%d] adminAddRoleManagersV3Conflict  %+v", 409, o.ToJSONString())
}

func (o *AdminAddRoleManagersV3Conflict) ToJSONString() string {
	if o.Payload == nil {
		return "{}"
	}

	b, err := json.Marshal(o.Payload)
	if err != nil {
		fmt.Println(err)

		return fmt.Sprintf("Failed to marshal the payload: %+v", o.Payload)
	}

	return fmt.Sprintf("%+v", string(b))
}

func (o *AdminAddRoleManagersV3Conflict) GetPayload() *iamclientmodels.RestErrorResponse {
	return o.Payload
}

func (o *AdminAddRoleManagersV3Conflict) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
	// handle file responses
	contentDisposition := response.GetHeader("Content-Disposition")
	if strings.Contains(strings.ToLower(contentDisposition), "filename=") {
		consumer = runtime.ByteStreamConsumer()
	}

	o.Payload = new(iamclientmodels.RestErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

repository: AccelByte/accelbyte-go-sdk

repo_name: AccelByte/accelbyte-go-sdk

branch_name: refs/heads/main

gha_language: Go


text:
@inproceedings{DBLP:conf/birthday/MontanariSS18,
  author    = {Ugo Montanari and
               Matteo Sammartino and
               Alain Tcheukam Siwe},
  title     = {Decomposition Structures for Soft Constraint Evaluation Problems:
               An Algebraic Approach},
abstract = {(Soft) Constraint Satisfaction Problems (SCSPs) are expressive and well-studied formalisms to represent and solve constraintsatisfaction and optimization problems. A variety of algorithms to tackle
them have been studied in the last 45 years, many of them based on
dynamic programming. A limit of SCSPs is its lack of compositionality
and, consequently, it is not possible to represent problem decompositions
in the formalism itself. In this paper we introduce Soft Constraint Evaluation Problems (SCEPs), an algebraic framework, generalizing SCSPs,
which allows for the compositional specification and resolution of (soft)
constraint-based problems. This enables the systematic derivation of efficient dynamic programming algorithms for any such problem.},
  booktitle = {Graph Transformation, Specifications, and Nets},
  series    = {Lecture Notes in Computer Science},
  volume    = {10800},
  pages     = {179--200},
  publisher = {Springer},
  year      = {2018},
  pdf       = {GTSN18.pdf}
}

@inproceedings{DBLP:conf/fm/AlbertGRS018,
  author    = {Elvira Albert and
               Miguel G{\'{o}}mez{-}Zamalloa and
               Albert Rubio and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {SDN-Actors: Modeling and Verification of {SDN} Programs},
  abstract = {Software-Defined Networking (SDN) is a recent networking paradigm that has become increasingly popular in the last decade. It gives unprecedented control over the global behavior of the network and provides a new opportunity for formal methods. Much work has been published in the last few years on providing bridges between SDN and verification. This paper advances this research line and provides a link between SDN and traditional work on formal methods for verification of distributed software-actor-based modeling. We show how SDN programs can be seamlessly modeled using actors, and thus existing advanced model checking techniques are developed for use with SDN networks, including consistency of flow tables, violation of safety policies, and forwarding loops.},
  booktitle = {Formal Methods - 22nd International Symposium {(FM)}},
  series    = {Lecture Notes in Computer Science},
  volume    = {10951},
  pages     = {550--567},
  publisher = {Springer},
  year      = {2018},
  pdf       = {FM18.pdf}
}

@article{DBLP:journals/corr/abs-1811-06968,
  author    = {Loris D'Antoni and
               Tiago Ferreira and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {Symbolic Register Automata},
  abstract = {Symbolic Finite Automata and Register Automata are two orthogonal extensions of finite automata motivated by real-world problems where data may have unbounded domains. These automata address a demand for a model over large or infinite alphabets, respectively. Both automata models have interesting applications and have been successful in their own right. In this paper, we introduce Symbolic Register Automata, a new powerful model that combines features from both symbolic and register automata, with a view on applications that were previously out of reach. We study their properties and provide algorithms for emptiness, inclusion and equivalence checking, together with experimental results.},
  journal   = {CoRR},
  volume    = {abs/1811.06968},
  year      = {2018},
  arxiv = {1811.06968}
}

@inproceedings{DBLP:conf/csl/HeerdtS017,
  author    = {Gerco {van Heerdt} and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {{CALF:} Categorical Automata Learning Framework},
  booktitle = {26th EACSL Annual Conference
Computer Science Logics (CSL)},
  abstract = {Automata learning is a technique that has successfully been applied in verification, with the
automaton type varying depending on the application domain. Adaptations of automata learning
algorithms for increasingly complex types of automata have to be developed from scratch because
there was no abstract theory offering guidelines. This makes it hard to devise such algorithms,
and it obscures their correctness proofs. We introduce a simple category-theoretic formalism that
provides an appropriately abstract foundation for studying automata learning. Furthermore, our
framework establishes formal relations between algorithms for learning, testing, and minimization.
We illustrate its generality with two examples: deterministic and weighted automata.},
  series    = {LIPIcs},
  volume    = {82},
  pages     = {29:1--29:24},
  publisher = {Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik},
  year      = {2017},
  pdf = {CSL17.pdf}
}

@inproceedings{DBLP:conf/popl/MoermanS0KS17,
  author    = {Joshua Moerman and
               Matteo Sammartino and
               Alexandra Silva and
               Bartek Klin and
               Michal Szynwelski},
  title     = {Learning nominal automata},
  abstract = {We present an Angluin-style algorithm to learn nominal automata, which are acceptors of languages over infinite (structured) alphabets. The abstract approach we take allows us to seamlessly extend known variations of the algorithm to this new setting. In particular we can learn a subclass of nominal non-deterministic automata. An implementation using a recently developed Haskell library for nominal computation is provided for preliminary experiments.},
  booktitle = {44th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL)},
  pages     = {613--625},
  publisher = {{ACM}},
  year      = {2017},
  pdf = {POPL17}
}

@article{DBLP:journals/corr/HeerdtS017a,
  author    = {Gerco {van Heerdt} and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {Optimizing Automata Learning via Monads},
  abstract = {Automata learning has been successfully applied in the verification of hardware and software. The size of the automaton model learned is a bottleneck for scalability, and hence optimizations that enable learning of compact representations are important. This paper exploits monads, both as a mathematical structure and a programming construct, to design, prove correct, and implement a wide class of such optimizations. The former perspective on monads allows us to develop a new algorithm and accompanying correctness proofs, building upon a general framework for automata learning based on category theory. The new algorithm is parametric on a monad, which provides a rich algebraic structure to capture non-determinism and other side-effects. We show that our approach allows us to uniformly capture existing algorithms, develop new ones, and add optimizations. The latter perspective allows us to effortlessly translate the theory into practice: we provide a Haskell library implementing our general framework, and we show experimental results for two specific instances: non-deterministic and weighted automata.},
  journal   = {CoRR},
  volume    = {abs/1704.08055},
  year      = {2017},
  arxiv = {1704.08055}
}

@article{DBLP:journals/acta/BruniMS15,
  author    = {Roberto Bruni and
               Ugo Montanari and
               Matteo Sammartino},
  title     = {Revisiting causality, coalgebraically},
  abstract = {In this paper we recast the classical Darondeau–Degano’s causal semantics of concurrency in a coalgebraic setting, where we derive a compact model. Our construction is inspired by the one of Montanari and Pistore yielding causal automata, but we show that it is instance of an existing categorical framework for modeling the semantics of nominal calculi, whose relevance is further demonstrated. The key idea is to represent events as names, and the occurrence of a new event as name generation. We model causal semantics as a coalgebra over a presheaf, along the lines of the Fiore–Turi approach to the semantics of nominal calculi. More specifically, we take a suitable category of finite posets, representing causal relations over events, and we equip it with an endofunctor that allocates new events and relates them to their causes. Presheaves over this category express the relationship between processes and causal relations among the processes’ events. We use the allocation operator to define a category of well-behaved coalgebras: it models the occurrence of a new event along each transition. Then we turn the causal transition relation into a coalgebra in this category, where labels only exhibit maximal events with respect to the source states’ poset, and we show that its bisimilarity is essentially Darondeau–Degano’s strong causal bisimilarity. This coalgebra is still infinite-state, but we exploit the equivalence between coalgebras over a class of presheaves and History Dependent automata to derive a compact representation, where states only retain the poset of the most recent events for each atomic subprocess, and are isomorphic up to order-preserving permutations. Remarkably, this reduction of states is automatically performed along the equivalence.},
  journal   = {Acta Informatica},
  volume    = {52},
  number    = {1},
  pages     = {5--33},
  year      = {2015},
  pdf = {ACTA14.pdf}
}

@inproceedings{DBLP:journals/entcs/MontanariS15,
  author    = {Ugo Montanari and
               Matteo Sammartino},
  title     = {Network-Conscious π-calculus - {A} Model of Pastry},
  booktitle = {Ninth Workshop on Logical and Semantic Frameworks, with Applications (LSFA)},
  abstract = {A peer-to-peer (p2p) system provides the networking substrate for the execution of distributed applications. It is made of peers that interact over an overlay network. Overlay networks are highly dynamic, as peers can join and leave at any time. Traditional process calculi, such as π-calculus, CCS and others, seem inadequate to capture these kinds of networks, their routing mechanisms, and to verify their properties. In order to model network architecture in a more explicit way, in [Ugo Montanari and Matteo Sammartino. Network conscious π-calculus: A concurrent semantics. ENTCS, 286:291–306, 2012; Matteo Sammartino. A Network-Aware Process Calculus for Global Computing and its Categorical Framework. PhD thesis, University of Pisa, 2013. available at http://www.di.unipi.it/~sammarti/publications/thesis.pdf; Ugo Montanari and Matteo Sammartino. A network-conscious π-calculus and its coalgebraic semantics. Theor. Comput. Sci., 546:188–224, 2014] we have introduced the Network Conscious π-calculus (NCPi), an extension of the π-calculus with names representing network nodes and links. In [Ugo Montanari and Matteo Sammartino. A network–conscious π-calculus and its coalgebraic semantics. Theor. Comput. Sci., 546:188–224, 2014] (a simpler version of) NCPi has been equipped with a coalgebraic operational models, along the lines of Fiore-Turi presheaf-based approach [Marcelo P. Fiore and Daniele Turi. Semantics of name and value passing. In LICS 2001, pages 93–104. IEEE Computer Society, 2001], and with an equivalent History Dependent Automaton [Ugo Montanari and Marco Pistore. Structured coalgebras and minimal hd-automata for the π-calculus. Theor. Comput. Sci., 340(3):539–576, 2005], i.e., an (often) finite-state automaton suitable for verification. In this paper we first give a brief account of these results. Then, our contribution is the sketch of a NCPi representation of the p2p architecture Pastry. In particular, we give models of its overlay network and of a Distributed Hash Table built on top of it, and we give evidence of their correctness by proving convergence of routing mechanisms.},
  series   = {Electr. Notes Theor. Comput. Sci.},
  volume    = {312},
  pages     = {3--17},
  year      = {2015},
  pdf = {LSFA14.pdf}
}

@article{DBLP:journals/jlp/BruniMS15,
  author    = {Roberto Bruni and
               Ugo Montanari and
               Matteo Sammartino},
  title     = {A coalgebraic semantics for causality in Petri nets},
  abstract = {In this paper we revisit some pioneering efforts to equip Petri nets with compact operational models for expressing causality. The models we propose have a bisimilarity relation and a minimal representative for each equivalence class, and they can be fully explained as coalgebras on a presheaf category on an index category of partial orders. First, we provide a set-theoretic model in the form of a causal case graph, that is a labeled transition system where states and transitions represent markings and firings of the net, respectively, and are equipped with causal information. Most importantly, each state has a poset representing causal dependencies among past events. Our first result shows the correspondence with behavior structure semantics as proposed by Trakhtenbrot and Rabinovich. Causal case graphs may be infinitely-branching and have infinitely many states, but we show how they can be refined to get an equivalent finitely-branching model. In it, states only keep the most recent causes for each token, are up to isomorphism, and are equipped with a symmetry, i.e., a group of poset isomorphisms. Symmetries are essential for the existence of a minimal, often finite-state, model. This first part requires no knowledge of category theory. The next step is constructing a coalgebraic model. We exploit the fact that events can be represented as names, and event generation as name generation. Thus we can apply the Fiore–Turi framework, where the semantics of nominal calculi are modeled as coalgebras over presheaves. We model causal relations as a suitable category of posets with action labels, and generation of new events with causal dependencies as an endofunctor on this category. Presheaves indexed by labeled posets represent the functorial association between states and their causal information. Then we define a well-behaved category of coalgebras. Our coalgebraic model is still infinite-state, but we exploit the equivalence between coalgebras over a class of presheaves and History Dependent automata to derive a compact representation, which is equivalent to our set-theoretical compact model. Remarkably, state reduction is automatically performed along the equivalence.},
  journal   = {Journal of Logical and Algebraic Methods in Programming},
  volume    = {84},
  number    = {6},
  pages     = {853--883},
  year      = {2015},
  pdf = {JLAMP15.pdf}
}

@inproceedings{DBLP:conf/birthday/BruniMS15,
  author    = {Roberto Bruni and
               Ugo Montanari and
               Matteo Sammartino},
  title     = {Causal Trees, Finally},
  abstract = {Causal trees are one of the earliest pioneering contributions of Pierpaolo Degano, in joint work with Philippe Darondeau. The idea is to record causality dependencies in processes and in their actions. As such, causal trees sit between interleaving models and truly concurrent ones and they originate an abstract, event-based bisimulation semantics for causal processes, where, intuitively, minimal causal trees represent the semantic domain. In the paper we substantiate this feeling, by first defining a nominal, compositional operational semantics based on History-Dependent automata and then we apply categorical techniques, based on named-sets, showing that causal trees form the final coalgebra semantics of a suitable coalgebraic representation of causal behaviour.},
  booktitle = {Programming Languages with Applications to Biology and Security},
  series    = {Lecture Notes in Computer Science},
  volume    = {9465},
  pages     = {27--43},
  publisher = {Springer},
  year      = {2015},
  pdf = {ct.pdf}
}

@inproceedings{DBLP:journals/corr/HochMS15,
  author    = {Nicklas Hoch and
               Ugo Montanari and
               Matteo Sammartino},
  title     = {Dynamic Programming on Nominal Graphs},
  abstract = {Many optimization problems can be naturally represented as (hyper) graphs, where vertices correspond to variables and edges to tasks, whose cost depends on the values of the adjacent variables. Capitalizing on the structure of the graph, suitable dynamic programming strategies can select certain orders of evaluation of the variables which guarantee to reach both an optimal solution and a minimal size of the tables computed in the optimization process. In this paper we introduce a simple algebraic specification with parallel composition and restriction whose terms up to structural axioms are the graphs mentioned above. In addition, free (unrestricted) vertices are labelled with variables, and the specification includes operations of name permutation with finite support. We show a correspondence between the well-known tree decompositions of graphs and our terms. If an axiom of scope extension is dropped, several (hierarchical) terms actually correspond to the same graph. A suitable graphical structure can be found, corresponding to every hierarchical term. Evaluating such a graphical structure in some target algebra yields a dynamic programming strategy. If the target algebra satisfies the scope extension axiom, then the result does not depend on the particular structure, but only on the original graph. We apply our approach to the parking optimization problem developed in the ASCENS e-mobility case study, in collaboration with Volkswagen. Dynamic programming evaluations are particularly interesting for autonomic systems, where actual behavior often consists of propagating local knowledge to obtain global knowledge and getting it back for local decisions.},
  booktitle = {Graphs ad Models},
  series    = {{EPTCS}},
  volume    = {181},
  pages     = {80--96},
  year      = {2015},
  pdf = {GAM15.pdf}
}

@inbook{Bruni2015,
author="Bruni, Roberto
and Montanari, Ugo
and Sammartino, Matteo",
editor="Wirsing, Martin
and H{\"o}lzl, Matthias
and Koch, Nora
and Mayer, Philip",
title="Reconfigurable and Software-Defined Networks of Connectors and Components",
bookTitle="Software Engineering for Collective Autonomic Systems: The ASCENS Approach",
year="2015",
publisher="Springer International Publishing",
address="Cham",
pages="73--106",
abstract="The diffusion of adaptive systems motivate the study of models of software entities whose interaction capabilities can evolve dynamically. In this paper we overview the contributions in the ASCENS project in the area of software defined networks and of reconfigurable connectors. In particular we highlight: (i) the definition of the Network-conscious π-calculus and its use in the modeling and verification of the PASTRY protocol, and (ii) the mutual correspondence between different frameworks for defining networks of connectors together with two suitable enhancements for addressing dynamically changing systems.",
isbn="978-3-319-16310-9",
doi="10.1007/978-3-319-16310-9_2",
url="https://doi.org/10.1007/978-3-319-16310-9_2"
}

@inbook{Hoch2015,
author="Hoch, Nicklas
and Monreale, Giacoma Valentina
and Montanari, Ugo
and Sammartino, Matteo
and Siwe, Alain Tcheukam",
editor="Wirsing, Martin
and H{\"o}lzl, Matthias
and Koch, Nora
and Mayer, Philip",
title="From Local to Global Knowledge and Back",
bookTitle="Software Engineering for Collective Autonomic Systems: The ASCENS Approach",
year="2015",
publisher="Springer International Publishing",
address="Cham",
pages="185--220",
abstract="Two forms of knowledge are considered: declarative and procedural. The former is easy to extend but it is equipped with expensive deduction mechanisms, while the latter is efficiently executable but it can hardly anticipate all the special cases. In the first part of this chapter (Sections 2 and 3), we first define a syntactic representation of Soft Constraint Satisfaction Problems (SCSPs), which allows us to express dynamic programming (DP) strategies. For the e-mobility case study of ASCENS, we use Soft Constraint Logic Programming (SCLP) to program (in CIAO Prolog) and solve local optimization problems of single electric vehicles. Then we treat the global optimization problem of finding optimal parking spots for all the cars. We provide: (i) a Java orchestrator for the coordination of local SCLP optimizations; and (ii) a DP algorithm, which corresponds to a local to global propagation and back. In the second part of this chapter (SectionÂ 4) we assume that different subjects are entitled to decide. The case study concerns a smart grid model where various prosumers (producers-consumers) negotiate (in real time, according to the DEZENT approach) the cost of the exchanged energy. Then each consumer tries to plan an optimal consumption profile (computed via DP) where (s)he uses less energy when it is expensive and more energy when it is cheap, conversely for a producer. Finally, the notion of an aggregator is introduced, whose aim is to sell flexibility to the market.",
isbn="978-3-319-16310-9",
doi="10.1007/978-3-319-16310-9_5",
url="https://doi.org/10.1007/978-3-319-16310-9_5"
}

@article{DBLP:journals/tcs/MontanariS14,
  author    = {Ugo Montanari and
               Matteo Sammartino},
  title     = {A network-conscious π-calculus and its coalgebraic semantics},
  abstract = {Traditional process calculi usually abstract away from network details, modeling only communication over shared channels. They, however, seem inadequate to describe new network architectures, such as Software Defined Networks, where programs are allowed to manipulate the infrastructure. In this paper we present the Network Conscious π-calculus ( NCPi), a proper extension of the π-calculus with an explicit notion of network: network links and nodes are represented as names, in full analogy with ordinary π-calculus names, and observations are routing paths through which data is transported. However, restricted links do not appear in the observations, which thus can possibly be as abstract as in the π-calculus. Then we construct a presheaf-based coalgebraic semantics for NCPi along the lines of Turi–Plotkin's approach, by indexing processes with the network resources they use: we give a model for observational equivalence in this context, and we prove that it admits an equivalent nominal automaton (HD-automaton), suitable for verification. Finally, we give a concurrent semantics for NCPi where observations are multisets of routing paths. We show that bisimilarity for this semantics is a congruence, and this property holds also for the concurrent version of the π-calculus.},
  journal   = {Theoretical Computer Science},
  volume    = {546},
  pages     = {188--224},
  year      = {2014},
  pdf = {TCS14.pdf}
}

@inproceedings{DBLP:conf/tgc/CianciaS14,
  author    = {Vincenzo Ciancia and
               Matteo Sammartino},
  title     = {A Class of Automata for the Verification of Infinite, Resource-Allocating
               Behaviours},
  abstract = {Process calculi for service-oriented computing often feature generation of fresh resources. So-called nominal automata have been studied both as semantic models for such calculi, and as acceptors of languages of finite words over infinite alphabets. In this paper we investigate nominal automata that accept infinite words. These automata are a generalisation of deterministic Muller automata to the setting of nominal sets. We prove decidability of complement, union, intersection, emptiness and equivalence, and determinacy by ultimately periodic words. The key to obtain such results is to use finite representations of the (otherwise infinite-state) defined class of automata. The definition of such operations enables model checking of process calculi featuring infinite behaviours, and resource allocation, to be implemented using classical automata-theoretic methods.},
  booktitle = {9th Symposium on Trustworthy Global Computing {(TGC)}},
  series    = {Lecture Notes in Computer Science},
  volume    = {8902},
  pages     = {97--111},
  publisher = {Springer},
  year      = {2014},
  pdf = {TGC14.pdf}
}

@article{DBLP:journals/corr/CianciaS13,
  author    = {Vincenzo Ciancia and
               Matteo Sammartino},
  title     = {A decidable class of (nominal) omega-regular languages over an infinite
               alphabet},
  abstract = {We define a class of languages of infinite words over infinite alphabets, and the corresponding automata. The automata used for recognition are a generalisation of deterministic Muller automata to the setting of nominal sets. Remarkably, the obtained languages are determined by their ultimately periodic fragments, as in the classical case. Closure under complement, union and intersection, and decidability of emptiness and equivalence are preserved by the generalisation. This is shown by using finite representations of the (otherwise infinite-state) defined class of automata.},
  journal   = {CoRR},
  volume    = {abs/1310.3945},
  year      = {2013},
  arxiv = {1310.3945}
}

@inproceedings{DBLP:journals/entcs/MontanariS12,
  author    = {Ugo Montanari and
               Matteo Sammartino},
  title     = {Network Conscious π-calculus: {A} Concurrent Semantics},
  booktitle = {28th Conference on the Mathematical Foundations of Programming Semantics {(MFPS)}},
  abstract = {Traditional process calculi usually abstract away from network details, modeling only communication over shared channels. They, however, seem inadequate to describe new network architectures, such as Software Defined Networks [Openflow foundation website, http://www.openflow.org/], where programs are allowed to manipulate the infrastructure. In this paper we present a network conscious, proper extension of the π-calculus: we add connector names and the primitives to handle them, and we provide a concurrent semantics. The extension to connector names is natural and seamless, since they are handled in full analogy with ordinary names. Our observations are multisets of routing paths through which sent and received data are transported. However, restricted connector names do not appear in the observations, which thus can possibly be as abstract as in the π-calculus. Finally, we show that bisimilarity is a congruence, and this property holds also for the concurrent version of the π-calculus.},
  series   = {Electr. Notes Theor. Comput. Sci.},
  volume    = {286},
  pages     = {291--306},
  year      = {2012},
  pdf = {mfps28.pdf}
}

@inproceedings{CAV19,
  author = {Loris D'Antoni and Tiago Ferreira and Matteo Sammartino and Alexandra Silva},
  title = {Symbolic Register Automata},
  booktitle = {31st International Conference on Computer-Aided Verification {(CAV)} },
  abstract = {Symbolic Finite Automata and Register Automata are two orthogonal extensions of finite automata motivated by real-world problems where data may have unbounded domains. These automata address a demand for a model over large or infinite alphabets, respectively. Both automata models have interesting applications and have been successful in their own right.  In this paper, we introduce Symbolic Register Automata, a new model that combines features from both symbolic and register automata, with a view on applications that were previously out of reach. We study their properties and provide algorithms for emptiness, inclusion and equivalence checking, together with experimental results.},
  year = {2019},
  pdf = {cav19.pdf}
}

@article{JLAMP19,
  title = {A (co)algebraic theory of succinct automata},
  author = {Gerco van Heerdt and Joshua Moerman and Matteo Sammartino and Alexandra Silva},
  abstract = {The classical subset construction for non-deterministic automata can be generalized to other side-effects captured by a monad.
	The key insight is that both the state space of the determinized automaton and its semantics---languages over an alphabet---have a common algebraic structure: they are Eilenberg-Moore algebras for the powersetgen monad.
	In this paper we study the reverse question to determinization.
	We will present a construction to associate succinct automata to languages based on different algebraic structures.
	For instance, for classical regular languages the construction will transform a deterministic automaton into a non-deterministic one, where the states represent the join-irreducibles of the language accepted by a (potentially) larger deterministic automaton.
	Other examples will yield alternating automata, automata with symmetries, CABA-structured automata, and weighted automata.},
  journal   = {Journal of Logical and Algebraic Methods in Programming},
  year = {2019},
  pdf = {jlamp19.pdf}
}

@inproceedings{CALCO19,
  title = {Tree Automata as Algebras: Minimisation and Determinisation},
  author = {Gerco van Heerdt and Tobias Kappe and Jurriaan Rot and Matteo Sammartino and Alexandra Silva},
  abstract = {We study a categorical generalisation of tree automata, as $\Sigma$-algebras for a fixed endofunctor $\Sigma$ endowed with initial and final states.
Under mild assumptions about the base category, we present a general minimisation algorithm for these automata.
We build upon and extend an existing generalisation of the Nerode equivalence to a categorical setting, and relate it to the existence of minimal automata.
Lastly, we show that generalised types of side-effects, such as non-determinism, can be captured by this framework, which leads to a general determinisation procedure.},
  booktitle = {8th Conference on Algebra and Coalgebra in Computer Science (CALCO)},
  year = {2019},
  pdf = {calco19.pdf}
}

@inproceedings{FSTTCS19,
  title = {A Categorical Account of Replicated Data Types},
  author = {Fabio Gadducci and Hernan Melgratti and Christian Roldan and Matteo Sammartino},
  abstract = {Replicated Data Types (RDTs) have been introduced as a suitable abstraction for dealing with weakly consistent data stores, which may (temporarily) expose multiple, inconsistent views of their state. In the literature, RDTs are commonly specified in terms of two relations: visibility, which accounts for the different views that a store may have, and arbitration, which states the logical order imposed on the operations executed over the store. Different flavours, e.g., operational, axiomatic and functional, have
recently been proposed for the specification of RDTs. In this work, we propose an algebraic characterisation of RDT specifications. We define categories of visibility relations and arbitrations, show the existence of relevant limits and colimits,
and characterize RDT specifications as functors between such categories that preserve these additional structures.},
  booktitle = {39th IARCS Annual Conference on. Foundations of Software Technology and Theoretical Computer Science (FSTTCS)},
  year = {2019},
  pdf = {fsttcs19.pdf}
}

@inproceedings{ICGT20,
  title = {Algebras for Tree Decomposable Graphs},
  booktitle = {Graph Transformation - 13th International Conference ({ICGT})},
  author = {Roberto Bruni and
               Ugo Montanari and
               Matteo Sammartino},
  year= {2020},
  abstract = {Complex problems can be sometimes solved efficiently via recursive decomposition strategies. In this line, the tree decomposition approach equips problems modelled as graphs with tree-like parsing structures. Following Milner’s flowgraph algebra, in a previous paper two of the authors introduced a strong network algebra to represent open graphs (up to isomorphism), so that homomorphic properties of open graphs can be computed via structural recursion. This paper extends this graphical-algebraic foundation to tree decomposable graphs. The correspondence is shown: (i) on the algebraic side by a loose network algebra, which relaxes the restriction reordering and scope extension axioms of the strong one; and (ii) on the graphical side by Milner’s binding bigraphs, and elementary tree decompositions. Conveniently, an interpreted loose algebra gives the evaluation complexity of each graph decomposition. As a key contribution, we apply our results to dynamic programming (DP). The initial statement of the problem is transformed into a term (this is the secondary optimisation problem of DP). Noting that when the scope extension axiom is applied to reduce the scope of the restriction, then also the complexity is reduced (or not changed), only so-called canonical terms (in the loose algebra) are considered. Then, the canonical term is evaluated obtaining a solution which is locally optimal for complexity. Finding a global optimum remains an NP-hard problem.},
  pdf = {ICGT20.pdf}
}

@inproceedings{CONCUR20,
title={Residual Nominal Automata},
author =	{Joshua Moerman and Matteo Sammartino},
booktitle = {31st International Conference on Concurrency Theory ({CONCUR})},
year = {2020},
abstract = {We are motivated by the following question: which nominal languages admit an active learning algorithm? This question was left open in previous work, and is particularly challenging for languages recognised by nondeterministic automata. To answer it, we develop the theory of residual nominal automata, a subclass of nondeterministic nominal automata. We prove that this class has canonical representatives, which can always be constructed via a finite number of observations. This property enables active learning algorithms, and makes up for the fact that residuality - a semantic property - is undecidable for nominal automata. Our construction for canonical residual automata is based on a machine-independent characterisation of residual languages, for which we develop new results in nominal lattice theory. Studying residuality in the context of nominal languages is a step towards a better understanding of learnability of automata with some sort of nondeterminism.},
pdf = {CONCUR20.pdf}
}

@inproceedings{DBLP:conf/cmcs/HeerdtS020,
  author    = {Gerco van Heerdt and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {Learning Automata with Side-Effects},
  booktitle = {Coalgebraic Methods in Computer Science - 15th International
               Workshop ({CMCS})},
  url       = {https://doi.org/10.1007/978-3-030-57201-3\_5},
  year = {2020},
  abstract = {Automata learning has been successfully applied in the verification of hardware and software. The size of the automaton model learned is a bottleneck for scalability, and hence optimizations that enable learning of compact representations are important. This paper exploits monads, both as a mathematical structure and a programming construct, to design and prove correct a wide class of such optimizations. Monads enable the development of a new learning algorithm and correctness proofs, building upon a general framework for automata learning based on category theory. The new algorithm is parametric on a monad, which provides a rich algebraic structure to capture non-determinism and other side-effects. We show that this allows us to uniformly capture existing algorithms, develop new ones, and add optimizations.},
  pdf = {CMCS20.pdf}
}

@inproceedings{ICTAC20,
  title = {Implementation correctness for Replicated Data Types, categorically},
  year = {2020},
  abstract = {Replicated Data Types (rdts) have been introduced as an abstraction for dealing with weakly consistent data stores, which may (temporarily) expose multiple, inconsistent views of their state. In the literature, rdts are usually presented in set-theoretical terms: Only re- cently different specification flavours have been proposed, among them a denotational formalism that inter alia captures specification refinement. So far, however, no abstract model has been proposed for the implemen- tations and their correctness with respect to specifications. This paper fills the gap: We first give categorical constructions for distilling an op- erational model from a specification, as well as its implementations, and then we define a notion of implementation correctness via simulation.},
  author = {Fabio Gadducci and Hernan Melgratti and Christian Roldan and Matteo Sammartino},
  booktitle = {17th International Colloquium on Theoretical Aspects of Computing ({ICTAC})},
  pdf = {ICTAC20.pdf},
  notes = {Best Paper Award}
}

@article{DBLP:journals/jlap/AlbertGIRSS21,
  author    = {Elvira Albert and
               Miguel G{\'{o}}mez{-}Zamalloa and
               Miguel Isabel and
               Albert Rubio and
               Matteo Sammartino and
               Alexandra Silva},
  title     = {Actor-based model checking for Software-Defined Networks},
  journal   = {Journal of Logical and Algebraic Methods in Programming},
  volume    = {118},
  pages     = {100617},
  year      = {2021},
  abstract = {Software-Defined Networking (SDN) is a networking paradigm that has become increasingly popular in the last decade. The unprecedented control over the global behavior of the network it provides opens a range of new opportunities for formal methods and much work has appeared in the last few years on providing bridges between SDN and verification. This article advances this research line and provides a link between SDN and traditional work on formal methods for verification of concurrent and distributed software---actor-based modelling. We show how SDN programs can be seamlessly modelled using <strong>actors</strong>, and thus existing advanced model checking techniques developed for actors can be directly applied to verify a range of properties of SDN networks, including consistency of flow tables, violation of safety policies, and forwarding loops. Our model checker for SDN networks is available through an online web interface, that also provides the SDN actor-models for a number of well-known SDN benchmarks.},
  pdf = {JLAMP20.pdf}
}


text:
SUMMARY = "OpenBMC fan control"
DESCRIPTION = "OpenBMC fan control."
PR = "r1"
PV = "1.0+git${SRCPV}"

inherit skeleton-sdbus
inherit obmc-phosphor-dbus-service
inherit pkgconfig

DEPENDS = "systemd"

SKELETON_DIR = "fanctl"

DBUS_SERVICE:${PN} += "org.openbmc.control.Fans.service"
SYSTEMD_SERVICE:${PN} += "obmc-max-fans.service"

repository: Intel-BMC/openbmc

repo_name: Intel-BMC/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
SUMMARY = "Artwork, styles and assets for the Breeze visual style for the Plasma Desktop"
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = " \
    file://COPYING;md5=5c213a7de3f013310bd272cdb6eb7a24 \
"

inherit kde-plasma gettext

DEPENDS += "\
    kauth-native \
    plasma-framework \
    ki18n \
    kcoreaddons \
    kcoreaddons-native \
    kguiaddons \
    kconfig \
    kconfig-native \
    kwidgetsaddons \
    kwindowsystem \
    kconfigwidgets \
    kdecoration \
    frameworkintegration \
    kcmutils \
    kpackage-native \
    ${@bb.utils.contains("DISTRO_FEATURES", "x11", "qtx11extras", "",d)} \
"

PV = "${PLASMA_VERSION}"
SRC_URI[md5sum] = "9b4240b531dc002c97a7c2da91087264"
SRC_URI[sha256sum] = "80abee69d458457837ae57195e0d62f7e7edcda6391a2f22ba6b3f5b9b9b5326"

FILES_${PN} += " \
    ${datadir}/color-schemes \
    ${datadir}/icons \
    ${datadir}/kconf_update \
    ${datadir}/kservices5 \
    ${datadir}/kstyle \
    ${datadir}/plasma \
    ${datadir}/QtCurve \
    ${datadir}/wallpapers \
    \
    ${OE_QMAKE_PATH_PLUGINS} \
    ${OE_QMAKE_PATH_QML} \
    ${libdir}/kconf_update_bin \
"

FILES_${PN}-dbg += " \
    ${libdir}/*/.debug \
    ${libdir}/*/*/.debug \
    ${OE_QMAKE_PATH_PLUGINS}/*/.debug \
"

RDEPENDS_${PN} += "milou"


text:
@book{kadushin_understanding_2012,
	address = {New York},
	title = {Understanding social networks: theories, concepts, and findings},
	isbn = {978-0-19-537946-4 978-0-19-537947-1},
	shorttitle = {Understanding social networks},
	publisher = {Oxford University Press},
	author = {Kadushin, Charles},
	year = {2012},
	keywords = {social networks},
	annote = {Introduction -- Basic network concepts: part I individual members of networks -- Basic network concepts: part II whole social networks -- Basic network concepts: part III network segmentation -- Psychological foundations of social networks -- Small groups, leadership and social networks -- Organizations and networks -- The small world, circles and communities -- Influence and diffusion -- Networks as social capital -- Ethical dilemmas of social network research -- Coda: ten master ideas of social networks}
}


text:
package awsutil

const (

	// AWS_EC2_INSTANCE is an Ec2 instance resource type
	AWS_EC2_INSTANCE = "AWS::EC2::Instance"

	// AWS_EC2_HOST is an Ec2 host resource type
	AWS_EC2_HOST = "AWS::EC2::Host"

	// EC2_INSTANCE_STATE_RUNNING is an Ec2 instance in a "running" state
	EC2_INSTANCE_STATE_RUNNING = "running"

)

repository: tleyden/awsutil

repo_name: tleyden/awsutil


text:
DESCRIPTION = "A pure Python 2/3 library for peripheral I/O (GPIO, LED, PWM, SPI, I2C, MMIO, Serial) in Linux."
HOMEPAGE = "http://pythonhosted.org/python-periphery/"
LICENSE = "MIT"

LIC_FILES_CHKSUM = "file://LICENSE;md5=30fe6f023a80fb33989fb3b9d773fea0"

SRC_URI[sha256sum] = "61d461d736982a6f766e878720ab10a68151e2e8c1086600d9389ac47e40e88a"

inherit pypi setuptools3

PYPI_PACKAGE = "python-periphery"

RDEPENDS:${PN} += "${PYTHON_PN}-mmap \
		${PYTHON_PN}-ctypes \
		${PYTHON_PN}-fcntl"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake