MeasureTheory/Intro1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Preliminaries \n",
    "\n",
    "## Set \n",
    "\n",
    "Let's introduce the concept of $ X $ Set \n",
    "\n",
    "In the code formalism we can think about it as \n",
    "```cpp\n",
    "class MathSet()\n",
    "{\n",
    "    // Generic Math related Set Class \n",
    "    \n",
    "    public: \n",
    "        // Returns true if \"element\" is an element of the present Set \n",
    "        bool isElement(MathElement element); \n",
    "    \n",
    "    private: \n",
    "        // Infrastructure to store Elements \n",
    "}\n",
    "```\n",
    "\n",
    "The name `MathSet` is used instead of `Set` in order to avoid confusion with `std::Set` \n",
    "\n",
    "Some more detailed examples are \n",
    "```cpp\n",
    "class Real : MathSet \n",
    "{\n",
    "    //Definition of a specific Set class namely the Real \n",
    "}\n",
    "\n",
    "class Complex : MathSet\n",
    "{\n",
    "    //Definition of a specific Set class namely the Complex\n",
    "}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measure over Space \n",
    "Let's consider a $ W \\subset X $ and let's think about answering the following question: \n",
    "\n",
    "<p style=\"color:red\"> what is the *volume* of this subset ?</p>\n",
    "\n",
    "In the math formalism this problem implies definining such a function \n",
    "$$ \\mu : X \\rightarrow \\mathbb{R}^{+} $$\n",
    "\n",
    "so that $ \\mu(W) $ can be interpreted as the *measure of the volume* of $ W $ ... whatever it means in the specific context of the $ X $ Set \n",
    "\n",
    "<!--<p style=\"border-style: solid; border-width:1px\">*Observe* <br/> You don't need any *a priori* definition for the $ X $ set </p>-->\n",
    "\n",
    "In the code formalism it could be implemented as follows \n",
    "```c++\n",
    "class MathSet \n",
    "{\n",
    "    // Method that returns a Subset of a given Set, according to some criteria \n",
    "    // Assuming well defined \n",
    "    MathSet getSubSet(SetCriteria sc); \n",
    "    \n",
    "    // Returns true if all the elements of the present set are also elements of the A set \n",
    "    // Assuming well defined \n",
    "    bool isSubSet(MathSet A); \n",
    "    \n",
    "    // Returns true if all the elements of the A set are also elements of the present set \n",
    "    // Assuming well defined \n",
    "    bool isSuperSet(MathSet A); \n",
    "    \n",
    "    \n",
    "    // [Note Here]\n",
    "    // Returns a Real Value, representing the Measure of the \"Volume\" of this Set and every Subset  \n",
    "    // Let's focus on this method \n",
    "    static Real getMeasure(); \n",
    "}\n",
    "  \n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decomposition of the Space \n",
    "\n",
    "Building the implementation of the `MathSet::getMeasure()` method is equivalent to defining the $ \\mu $ function. \n",
    "\n",
    "Instead of defining a value for each possible $ W \\subset X $ it is better to think *how to properly decompose* the $ X $ Set: the goal is to build a **Basis** exploiting which (by means of composition) it is possible to *describe every possible subset* in $ X $ set. \n",
    "\n",
    "A good basis is a **sigma algebra** which is a *collection of subsets* respecting certain properties wrt certain set operation functions \n",
    "\n",
    "Formally the `SigmaAlgebra` object is $ \\mathcal{M} \\subset \\mathcal{P}(X) $ where \n",
    "\n",
    "* $ \\mathcal{P}(X) $ is the Power Set of $ X $ \n",
    "\n",
    "So $ \\mathcal{M} $ represents a *collection of subsets* (chosen among all the possible ones wrt some criteria) so formally we have that \n",
    "\n",
    "```cpp\n",
    "class SigmaAlgebra\n",
    "{\n",
    "    // It is possible to build a Sigma Algebra defining explicitely a list of sets that compose it \n",
    "    SigmaAlgebra(std::vector<Set> setlist); \n",
    "    \n",
    "    private: \n",
    "        // Internal Representation of the Collection of Subsets defining the Sigma Algebra \n",
    "        std::vector<Set> m_SetList; \n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "Given a certain $ X $ Set there is not only one Sigma Algebra hence it is possible to introduce the concept of **Sigma Algebra Generator** that can be represented as follows \n",
    "```cpp \n",
    "class MathSet \n",
    "{\n",
    "    // ... all the previous definition ... \n",
    "    \n",
    "    // Specifying some criteria, it is possible to properly define a Sigma Algebra \n",
    "    SigmaAlgebra getSigmaAlgebra(SigmaAlgebraGenCriteria sa_criteria); \n",
    "    {\n",
    "        //This method returns a valid Sigma Algebra for this Set \n",
    "    }\n",
    "\n",
    "}\n",
    "```\n",
    "\n",
    "Once a Sigma Algebra is defined for a given space, every subset can be expressed on the Sigma Algebra Basis, this is equivalent to implement the following method \n",
    "\n",
    "```cpp \n",
    "class SigmaAlgebra \n",
    "{\n",
    "    // ... all the previous definition ... \n",
    "        \n",
    "    // Provides the representation of a generic Subset of the World Set according to the Sigma Algebra Basis \n",
    "    std::vector<MathSet> getRepresentation(MathSet set); \n",
    "}\n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Example1\n",
    "\n",
    "If we have $ W \\subset X $ in order to compute $ \\mu(W) $ we should proceed as follows \n",
    "\n",
    "* define $ \\mathcal{M} \\subset \\mathcal{P}(X) $ a Sigma Algebra for $ X $ \n",
    "* express $ W $ on $ \\mathcal{M} $ hence finding $ \\{ W_{i} \\}_{i=1,...,n}, \\forall W_{i} \\in \\mathcal{M} $ a set of Sigma Algebra elements so that $ W = \\bigcup_{i} W_{i} $ their composition defines the initial set \n",
    "* compute the measure as follows $ \\mu(W) = \\sum_{i=1}^{n} \\mu(W_{i}) $\n",
    "\n",
    "So defining $ \\mu $ just for the Sigma Algebra Elements is enough to provide a measure for all the elements of $ \\mathcal{P}(X) $ \n",
    "\n",
    "From the code point of view \n",
    "```cpp\n",
    "\n",
    "MathSet X,W; \n",
    "\n",
    "// Building W so that it is a subset of X \n",
    "\n",
    "// Build a Sigma Algebra for X (Standard Sigma Algebra)\n",
    "sa = X.getSigmaAlgebra();  \n",
    "\n",
    "// Get the Sigma Algebra representation \n",
    "std::vector<MathSet> w_list = sa.getRepresentation(W); \n",
    "\n",
    "```\n",
    "\n",
    "So in the end it will be needed to define only `MathSet::getMeasure(MathSet s)` only for `s` elements of the `std::vector<MathSet>`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.8"
  },
  "name": "MeasureTheory1.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}