publications.bib

@mastersthesis{simonet-dea00,
  author = {Vincent Simonet},
  title = {Inférence de flots d'information pour {ML}},
  year = {2001},
  month = mar,
  school = {DEA «~Programmation~: Sémantique, Preuves, et Langages~»},
  note = {In French},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-dea01.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-dea01.pdf}
}
@inproceedings{pottier-simonet-02,
  author = {François Pottier and Vincent Simonet},
  title = {Information Flow Inference for {ML}},
  booktitle = {Proceedings of the 29th {ACM} Symposium on
               Principles of Programming Languages (POPL'02)},
  pages = {319--330},
  acm = {http://doi.acm.org/10.1145/503272.503302},
  ps = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-popl02.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-popl02.pdf},
  long-ps = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-popl02-long.ps.gz},
  long-pdf = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-popl02-long.pdf},
  address = {Portland, Oregon},
  month = jan,
  year = {2002},
  note = {\copyright ACM},
  abstract = {This paper presents a type-based information flow
    analysis for a call-by-value lambda-calculus equipped with
    references, exceptions and let-polymorphism, which we refer to as
    Core ML. The type system is constraint-based and has decidable
    type inference. Its non-interference proof is reasonably
    light-weight, thanks to the use of a number of orthogonal
    techniques. First, a syntactic segregation between values and
    expressions allows a lighter formulation of the type
    system. Second, non-interference is reduced to subject reduction
    for a non-standard language extension. Lastly, a semi-syntactic
    approach to type soundness allows dealing with constraint-based
    polymorphism separately.}
}
@inproceedings{simonet-csfw-02,
  author = {Vincent Simonet},
  title = {Fine-grained Information Flow Analysis for a $\lambda$-calculus
           with Sum Types},
  booktitle = {Proceedings of the 15th {IEEE} 
               Computer Security Foundations Workshop (CSFW 15)},
  pages = {223--237},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-csfw-02.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-csfw-02.pdf},
  long-ps = {http://www.normalesup.org/~simonet/publis/simonet-csfw-02-long.ps.gz},
  long-pdf = {http://www.normalesup.org/~simonet/publis/simonet-csfw-02-long.pdf},
  address = {Cape Breton, Nova Scotia (Canada)},
  month = jun,
  year = {2002},
  note = {\copyright IEEE},
  abstract = {This paper presents a new type system tracing
    information flow for a $\lambda$-calculus equipped with
    polymorphic ``let'' and with sums (a.k.a.\ union types or
    polymorphic variants).  The type system allows establishing (weak)
    non-interference properties.  Thanks to original forms of security
    annotations and constraints, it is more accurate than existing
    analyses.  Through a straightforward encoding into sums, this work
    also provides a new type-based information flow analysis for
    programming languages featuring exceptions.  From these systems,
    one may derive constraint-based formulations, in the style of
    HM(X), which have decidable type inference.}
}
@inproceedings{simonet-wole-13,
  author = {Vincent Simonet},
  title = {Classifying {Y}ou{T}ube Channels: a Practical System},
  booktitle = {Proceedings of the 2nd International Workshop on Web of 
               Linked Entities (WOLE 2013), in Proceedings of the 22nd
               International conference on World Wide Web companion},
  pages = {1295-1304},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-wole-13.pdf},
  acm = {http://dl.acm.org/citation.cfm?id=2488164},
  google = {http://research.google.com/pubs/pub41156.html},
  address = {Rio de Janeiro (Brasil)},
  month = may,
  year = {2013},
  note = {\copyright ACM},
  abstract = {This paper presents a framework for categorizing
                  channels of videos in a thematic taxonomy with high
                  precision and coverage. The proposed approach
                  consists of three main steps. First, videos are
                  annotated by semantic entities describing their
                  central topics. Second, semantic entities are mapped
                  to categories using a combination of
                  classifiers.Last, the categorization of channels is
                  obtained by combining the results of both previous
                  steps.  This framework has been deployed on the
                  whole corpus of YouTube, in 8 languages, and used to
                  build several user facing products. Beyond the
                  description of the framework, this paper gives
                  insight into practical aspects and experience:
                  rationale from product requirements to the choice of
                  the solution, spam filtering, human-based
                  evaluations of the quality of the results, and
                  measured metrics on the live site.}
}
@article{pottier-simonet-toplas,
  author = {François Pottier and Vincent Simonet},
  title = {Information Flow Inference for {ML}},
  journal = {ACM Transactions on Programming Languages and Systems},
  volume = {25},
  number = {1},
  month = jan,
  year = 2003,
  pages = {117--158},
  acm = {http://doi.acm.org/10.1145/596980.596983},
  ps = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-toplas.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/fpottier-simonet-toplas.pdf},
  note = {\copyright ACM},
  abstract = {This paper presents a type-based information flow
    analysis for a call-by-value $\lambda$-calculus equip\-ped with
    references, exceptions and $let$-polymorphism, which we refer to
    as ML. The type system is constraint-based and has decidable type
    inference. Its noninterference proof is reasonably light-weight,
    thanks to the use of a number of orthogonal techniques. First, a
    syntactic segregation between \emph{values} and \emph{expressions}
    allows a lighter formulation of the type system. Second,
    noninterference is reduced to \emph{subject reduction} for a
    nonstandard language extension. Lastly, a \emph{semi-syntactic}
    approach to type soundness allows dealing with constraint-based
    polymorphism separately.}
}
@inproceedings{simonet-appsem-03,
  author = {Vincent Simonet},
  title = {{Flow} {Caml} in a Nutshell},
  booktitle = {Proceedings of the first APPSEM-II workshop},
  pages = {152--165},
  editor = {Graham Hutton},
  address = {Nottingham, United Kingdom},
  month = mar,
  year = 2003,
  abstract = {Flow Caml is an extension of the Objective Caml language
    with a type system tracing information flow.  It automatically
    checks information flow within Flow Caml programs, then translates
    them to regular Objective Caml code that can be compiled by the
    ordinary compiler to produce secure programs.  In this paper, we
    give a short overview of this system, from a practical viewpoint.}
}
@inproceedings{simonet-icfp-03,
  author = {Vincent Simonet},
  title = {An Extension of {HM(X)} with Bounded Existential and
           Universal Data-Types},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-icfp03.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-icfp03.pdf},
  long-ps = {http://www.normalesup.org/~simonet/publis/simonet-icfp03-full.ps.gz},
  long-pdf = {http://www.normalesup.org/~simonet/publis/simonet-icfp03-full.pdf},
  acm = {http://doi.acm.org/10.1145/944705.944710},
  month = aug,
  year = 2003,
  booktitle = {Proceedings of the 8th ACM SIGPLAN International Conference on 
               Functional Programming (ICFP 2003)},
  pages = {39--50},
  address = {Uppsala, Sweden},
  note = {\copyright ACM},
  abstract = {We propose a conservative extension of HM(X), a generic
    constraint-based type inference framework, with bounded
    existential (a.k.a. abstract) and universal (a.k.a. polymorphic)
    data-types.  In the first part of the article, which remains
    abstract of the type and constraint language (i.e. the logic X),
    we introduce the type system, prove its safety and define a type
    inference algorithm which computes principal typing judgments.  In
    the second part, we propose a realistic constraint solving
    algorithm for the case of structural subtyping, which handles the
    non-standard construct of the constraint language generated by
    type inference: a form of bounded universal quantification.}
}
@inproceedings{simonet-aplas-03,
  author = {Vincent Simonet},
  title = {Type inference with structural subtyping:
           A faithful formalization of an efficient constraint solver},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-aplas03.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-aplas03.pdf},
  long-ps = {http://www.normalesup.org/~simonet/publis/simonet-aplas03-full.ps.gz},
  long-pdf = {http://www.normalesup.org/~simonet/publis/simonet-aplas03-full.pdf},
  springer = {http://www.springerlink.com/link.asp?id=y21wma91n44y},
  month = nov,
  year = {2003},
  booktitle = {Proceedings of the Asian Symposium on
               Programming Languages and Systems (APLAS'03)},
  editor = {Atsushi Ohori},
  publisher = {Springer-Verlag},
  series = {Lecture Notes in Computer Science},
  pages = {283--302},
  volume = 2895,
  address = {Beijing, China},
  note = {\copyright Springer-Verlag},
  abstract = {We are interested in type inference in the presence of
    structural subtyping from a pragmatic perspective.  This work
    combines theoretical and practical contributions: first, it
    provides a faithful description of an efficient algorithm for
    solving and simplifying constraints; whose correctness is formally
    proved.  Besides, the framework has been implemented in Objective
    Caml, yielding a generic type inference engine.  Its efficiency is
    assessed by a complexity result and a series of experiments in
    realistic cases.}
}
@techreport{simonet-flowcaml-manual,
  author = {Vincent Simonet},
  title = {The {F}low {C}aml {S}ystem: documentation and user's manual},
  institution = {Institut National de Recherche en Informatique et
                 en Automatique (INRIA)},
  number = {0282},
  type = {Technical Report},
  html = {http://www.normalesup.org/~simonet/soft/flowcaml/manual/},
  ps = {http://www.normalesup.org/~simonet/soft/flowcaml/flowcaml-manual.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/soft/flowcaml/flowcaml-manual.pdf},
  inria = {http://www.inria.fr/rrrt/rt-0282.html},
  month = jul,
  year = {2003},
  note = {\copyright INRIA},
  abstract = {Flow Caml is an extension of the Objective Caml language
    with a type system tracing information flow.  Its purpose is
    basically to allow to write ``real'' programs and to automatically
    check that they obey some confidentiality or integrity policy.  In
    Flow Caml, standard ML types are annotated with security levels
    chosen in a user-definable lattice.  Each annotation gives an
    approximation of the information that the described expression may
    convey.  Because it has full type inference, the system verifies,
    without requiring source code annotations, that every information
    flow caused by the analyzed program is legal with regard to the
    security policy specified by the programmer.}
}
@techreport{simonet-pottier-hmg,
  author = {Vincent Simonet and François Pottier},
  title = {Constraint-Based Type Inference for Guarded Algebraic
                 Data Types},
  month = jan,
  year = {2005},
  institution = {INRIA},
  type = {Research Report},
  number = {5462},
  abstract = {\emph{Guarded} algebraic data types subsume the
    concepts known in the literature as \emph{indexed types},
    \emph{guarded recursive datatype constructors}, and
    \emph{first-class phantom types}, and are closely related to
    \emph{inductive types}. They have the distinguishing feature that,
    when typechecking a function defined by cases, every branch may be
    checked under different assumptions about the type variables in
    scope. This mechanism allows exploiting the presence of dynamic
    tests in the code to produce extra static type information.\par We
    propose an extension of the constraint-based type system {HM$(X)$}
    with deep pattern matching, guarded algebraic data types, and
    polymorphic recursion. We prove that the type system is sound and
    that, provided recursive function definitions carry a type
    annotation, type inference may be reduced to constraint
    solving. Then, because solving arbitrary constraints is expensive,
    we further restrict the form of type annotations and prove that
    this allows producing so-called \emph{tractable}
    constraints. Last, in the specific setting of equality, we explain
    how to solve tractable constraints.\par To the best of our
    knowledge, this is the first \emph{generic} and
    \emph{comprehensive} account of type inference in the presence of
    guarded algebraic data types.},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-pottier-hmg.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-pottier-hmg.pdf},
  inria = {http://www.inria.fr/rrrt/rr-5462.html}
}
@article{simonet-pottier-hmg-toplas,
  author = {Vincent Simonet and François Pottier},
  title = {A Constraint-Based Approach to Guarded Algebraic Data
                 Types},
  month = jan,
  year = {2007},
  journal = {ACM Transactions on Programming Languages and
                 Systems},
  acm = {http://dl.acm.org/citation.cfm?doid=1180475.1180476},
  volume = {29},
  number = {1},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-pottier-hmg-toplas.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-pottier-hmg-toplas.pdf},
  abstract = {We study {HMG$(X)$}, an extension of the
    constraint-based type system {HM$(X)$} with deep pattern matching,
    polymorphic recursion, and guarded algebraic data types. Guarded
    algebraic data types subsume the concepts known in the literature
    as indexed types, guarded recursive datatype constructors,
    (first-class) phantom types, and equality qualified types, and are
    closely related to inductive types.  Their characteristic property
    is to allow every branch of a case construct to be typechecked
    under different assumptions about the type variables in scope. We
    prove that {HMG$(X)$} is sound and that, provided recursive
    definitions carry a type annotation, type inference can be reduced
    to constraint solving. Constraint solving is decidable, at least
    for some instances of $X$, but prohibitively expensive. Effective
    type inference for guarded algebraic data types is left as an
    issue for future research.}
}
@phdthesis{simonet-these,
  author = {Vincent Simonet},
  title = {Inférence de flots d'information pour {ML}: 
           formalisation et implantation},
  ps = {http://www.normalesup.org/~simonet/publis/simonet-these.ps.gz},
  pdf = {http://www.normalesup.org/~simonet/publis/simonet-these.pdf},
  month = mar,
  year = {2004},
  school = {Université Paris 7},
  abstract = {This thesis describes the conception of an information flow
    analyser for a language of the ML family, from its theoretical
    foundation to the practical issues.  The first part of the
    dissertation presents the tool that was implemented, Flow Caml,
    and illustrates its use on concrete example.  The second part
    gives a formalization of the type system featured by Flow Caml,
    together with a proof of its correctness.  This is the first type
    system for information flow analysis in a realistic programming
    language that has been formally proved.  Lastly, the third part is
    devoted to the formalization and the proof of an efficient
    algorithm for type inference in the presence of structural
    subtyping and polymorphism.  An instance of this algorithm is used
    to synthesize types in Flow Caml.}
}

This file was generated by bibtex2html 1.97.