add rb-intro sheet 3

cd6a9249 · Stephan Rave · 5f1b44df · cd6a9249 · cd6a9249 · cd6a9249
Commit cd6a9249 authored 5 years ago by Stephan Rave
--- a/rb-intro/Sheet3.ipynb
+++ b/rb-intro/Sheet3.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# pyMOR RB-Intro\n",
+    "\n",
+    "# Exercise Sheet 3 - Solutions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pymor.basic import *\n",
+    "set_log_levels({'pymor': 'WARN',\n",
+    "                'pymor.functions.bitmap': 'CRITICAL'})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will continue to work with the models defined on exercise sheet 1. To simplify working with these models, you can find their definition in `problems.py` in the same directory as this notebook:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "from pymor.basic import *\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_1_a():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain([[0., 0.], [1., 1.]]),\r\n",
+      "\r\n",
+      "        diffusion=ConstantFunction(1, 2),\r\n",
+      "\r\n",
+      "        rhs=ExpressionFunction('(sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 1.', 2, ()),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_1a'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_1_b():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ConstantFunction(-1., 2),\r\n",
+      "\r\n",
+      "        diffusion=ExpressionFunction('1. - (sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 0.999', 2, ()),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_1b'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_1_c():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ConstantFunction(-1., 2),\r\n",
+      "\r\n",
+      "        diffusion=ExpressionFunction(\r\n",
+      "            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',\r\n",
+      "            2, (),\r\n",
+      "            values={'K': 10}\r\n",
+      "        ),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_1c'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_1_d():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ConstantFunction(-1., 2),\r\n",
+      "\r\n",
+      "        diffusion=BitmapFunction('RB.png', range=[0.001, 1]),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_1d'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_2_a():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),\r\n",
+      "\r\n",
+      "        diffusion=ExpressionFunction(\r\n",
+      "            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',\r\n",
+      "            2, (),\r\n",
+      "            values={'K': 10}\r\n",
+      "        ),\r\n",
+      "\r\n",
+      "        parameter_space=CubicParameterSpace({'neum': ()}, -10, 10),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_2a'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_2_b():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),\r\n",
+      "\r\n",
+      "        diffusion=ExpressionFunction(\r\n",
+      "            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * (1 - diffu)',\r\n",
+      "            2, (),\r\n",
+      "            values={'K': 10},\r\n",
+      "            parameter_type={'diffu': ()}\r\n",
+      "        ),\r\n",
+      "\r\n",
+      "        parameter_space=CubicParameterSpace(\r\n",
+      "            {'neum': (), 'diffu': ()},\r\n",
+      "            ranges={'diffu': [0.0001, 1.], 'neum': [-10, 10]}\r\n",
+      "        ),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_2b'\r\n",
+      "    )\r\n",
+      "\r\n",
+      "\r\n",
+      "def problem_1_2_c():\r\n",
+      "    return StationaryProblem(\r\n",
+      "        domain=RectDomain(bottom='neumann'),\r\n",
+      "\r\n",
+      "        neumann_data=ConstantFunction(-1., 2),\r\n",
+      "\r\n",
+      "        diffusion=LincombFunction(\r\n",
+      "            [ConstantFunction(1., 2),\r\n",
+      "             BitmapFunction('R.png', range=[1, 0]),\r\n",
+      "             BitmapFunction('B.png', range=[1, 0])],\r\n",
+      "            [1.,\r\n",
+      "             ExpressionParameterFunctional('-(1 - R)', {'R': ()}),\r\n",
+      "             ExpressionParameterFunctional('-(1 - B)', {'B': ()})]\r\n",
+      "        ),\r\n",
+      "\r\n",
+      "        parameter_space=CubicParameterSpace({'R': (), 'B': ()}, 0.0001, 1.),\r\n",
+      "\r\n",
+      "        name='Sheet1_Problem_2c'\r\n",
+      "    )\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cat problems.py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The file can be imported as usual:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import problems"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We have four non-parametric problems:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "for f in [problems.problem_1_1_a, problems.problem_1_1_b,\n",
+    "          problems.problem_1_1_c, problems.problem_1_1_d]:\n",
+    "    p = f()\n",
+    "    m, _ = discretize_stationary_cg(p, diameter=1/100)\n",
+    "    m.visualize(m.solve(), legend=m.name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The parametric problems have already been assigned a `ParameterSpace` which is inherited by the generated models:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for f in [problems.problem_1_2_a, problems.problem_1_2_b,\n",
+    "          problems.problem_1_2_c]:\n",
+    "    p = f()\n",
+    "    m, _ = discretize_stationary_cg(p, diameter=1/100)\n",
+    "    mu = m.parameter_space.sample_randomly(1)[0]\n",
+    "    m.visualize(m.solve(mu), legend=str(mu))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 1 a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Write a method\n",
+    "\n",
+    "```python\n",
+    "def orthogonal_projection(U, basis, product=None,\n",
+    "                          basis_is_orthonormal=False,\n",
+    "                          return_projection_matrix=False):\n",
+    "    ...\n",
+    "```\n",
+    "that encapsulates the orthogonal projection algorithm you implemented in Sheet 2, Problem 2."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 1 b)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Repeat the error calculations from Sheet 2, Problem 2 with an orthonormal basis obtained from `U`\n",
+    "using `pymor.algorithms.gram_schmidt`. Compare your results."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 2 a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Extend the `greedy` function from Sheet 2, Problem 3 to a function\n",
+    "\n",
+    "```python\n",
+    "    def greedy(U, basis_size, product=None,\n",
+    "               rtol=0,\n",
+    "               orthonormalize=False):\n",
+    "        ...\n",
+    "```\n",
+    "\n",
+    "The algorithm should stop, when the relative approximation error goes below the prescribed value `rtol`. When `orthonormalize` is set to `True`, the algorithm shall return an orthonormal basis w.r.t. to `product` by orthonormalizing each new snapshot vector w.r.t. `product`.\n",
+    "\n",
+    "**Hint:** When using `gram_schmidt` for orthonormalization, the `offset` parameter can be used to avoid re-orthonormalizing the old basis. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Problem 2 b)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Repeat the experiments from Sheet 2, Problem 3, using `strong_greedy` with `orthonormalize=True`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bonus Problem"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Write a function `word_problem` which, given an arbitrary string, generates a `StationaryProblem` similar to Sheet 1, Problem 2 (c). Each letter should have a corresponding parameter component.\n",
+    "\n",
+    "**Hint:** Use the modules `PIL.ImageDraw` und `PIL.ImageFont`."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+%% Cell type:markdown id: tags:
+
+# pyMOR RB-Intro
+
+# Exercise Sheet 3 - Solutions
+
+%% Cell type:code id: tags:
+
+``` python
+from pymor.basic import *
+set_log_levels({'pymor': 'WARN',
+                'pymor.functions.bitmap': 'CRITICAL'})
+```
+
+%% Cell type:markdown id: tags:
+
+We will continue to work with the models defined on exercise sheet 1. To simplify working with these models, you can find their definition in `problems.py` in the same directory as this notebook:
+
+%% Cell type:code id: tags:
+
+``` python
+%cat problems.py
+```
+
+%% Output
+
+    from pymor.basic import *
+    
+    
+    def problem_1_1_a():
+        return StationaryProblem(
+            domain=RectDomain([[0., 0.], [1., 1.]]),
+    
+            diffusion=ConstantFunction(1, 2),
+    
+            rhs=ExpressionFunction('(sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 1.', 2, ()),
+    
+            name='Sheet1_Problem_1a'
+        )
+    
+    
+    def problem_1_1_b():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ConstantFunction(-1., 2),
+    
+            diffusion=ExpressionFunction('1. - (sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 0.999', 2, ()),
+    
+            name='Sheet1_Problem_1b'
+        )
+    
+    
+    def problem_1_1_c():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ConstantFunction(-1., 2),
+    
+            diffusion=ExpressionFunction(
+                '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',
+                2, (),
+                values={'K': 10}
+            ),
+    
+            name='Sheet1_Problem_1c'
+        )
+    
+    
+    def problem_1_1_d():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ConstantFunction(-1., 2),
+    
+            diffusion=BitmapFunction('RB.png', range=[0.001, 1]),
+    
+            name='Sheet1_Problem_1d'
+        )
+    
+    
+    def problem_1_2_a():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),
+    
+            diffusion=ExpressionFunction(
+                '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',
+                2, (),
+                values={'K': 10}
+            ),
+    
+            parameter_space=CubicParameterSpace({'neum': ()}, -10, 10),
+    
+            name='Sheet1_Problem_2a'
+        )
+    
+    
+    def problem_1_2_b():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),
+    
+            diffusion=ExpressionFunction(
+                '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * (1 - diffu)',
+                2, (),
+                values={'K': 10},
+                parameter_type={'diffu': ()}
+            ),
+    
+            parameter_space=CubicParameterSpace(
+                {'neum': (), 'diffu': ()},
+                ranges={'diffu': [0.0001, 1.], 'neum': [-10, 10]}
+            ),
+    
+            name='Sheet1_Problem_2b'
+        )
+    
+    
+    def problem_1_2_c():
+        return StationaryProblem(
+            domain=RectDomain(bottom='neumann'),
+    
+            neumann_data=ConstantFunction(-1., 2),
+    
+            diffusion=LincombFunction(
+                [ConstantFunction(1., 2),
+                 BitmapFunction('R.png', range=[1, 0]),
+                 BitmapFunction('B.png', range=[1, 0])],
+                [1.,
+                 ExpressionParameterFunctional('-(1 - R)', {'R': ()}),
+                 ExpressionParameterFunctional('-(1 - B)', {'B': ()})]
+            ),
+    
+            parameter_space=CubicParameterSpace({'R': (), 'B': ()}, 0.0001, 1.),
+    
+            name='Sheet1_Problem_2c'
+        )
+
+%% Cell type:markdown id: tags:
+
+The file can be imported as usual:
+
+%% Cell type:code id: tags:
+
+``` python
+import problems
+```
+
+%% Cell type:markdown id: tags:
+
+We have four non-parametric problems:
+
+%% Cell type:code id: tags:
+
+``` python
+for f in [problems.problem_1_1_a, problems.problem_1_1_b,
+          problems.problem_1_1_c, problems.problem_1_1_d]:
+    p = f()
+    m, _ = discretize_stationary_cg(p, diameter=1/100)
+    m.visualize(m.solve(), legend=m.name)
+```
+
+%% Cell type:markdown id: tags:
+
+The parametric problems have already been assigned a `ParameterSpace` which is inherited by the generated models:
+
+%% Cell type:code id: tags:
+
+``` python
+for f in [problems.problem_1_2_a, problems.problem_1_2_b,
+          problems.problem_1_2_c]:
+    p = f()
+    m, _ = discretize_stationary_cg(p, diameter=1/100)
+    mu = m.parameter_space.sample_randomly(1)[0]
+    m.visualize(m.solve(mu), legend=str(mu))
+```
+
+%% Cell type:markdown id: tags:
+
+## Problem 1
+
+%% Cell type:markdown id: tags:
+
+## Problem 1 a)
+
+%% Cell type:markdown id: tags:
+
+Write a method
+
+```python
+def orthogonal_projection(U, basis, product=None,
+                          basis_is_orthonormal=False,
+                          return_projection_matrix=False):
+    ...
+```
+that encapsulates the orthogonal projection algorithm you implemented in Sheet 2, Problem 2.
+
+%% Cell type:markdown id: tags:
+
+## Problem 1 b)
+
+%% Cell type:markdown id: tags:
+
+Repeat the error calculations from Sheet 2, Problem 2 with an orthonormal basis obtained from `U`
+using `pymor.algorithms.gram_schmidt`. Compare your results.
+
+%% Cell type:markdown id: tags:
+
+## Problem 2
+
+%% Cell type:markdown id: tags:
+
+## Problem 2 a)
+
+%% Cell type:markdown id: tags:
+
+Extend the `greedy` function from Sheet 2, Problem 3 to a function
+
+```python
+    def greedy(U, basis_size, product=None,
+               rtol=0,
+               orthonormalize=False):
+        ...
+```
+
+The algorithm should stop, when the relative approximation error goes below the prescribed value `rtol`. When `orthonormalize` is set to `True`, the algorithm shall return an orthonormal basis w.r.t. to `product` by orthonormalizing each new snapshot vector w.r.t. `product`.
+
+**Hint:** When using `gram_schmidt` for orthonormalization, the `offset` parameter can be used to avoid re-orthonormalizing the old basis.
+
+%% Cell type:markdown id: tags:
+
+## Problem 2 b)
+
+%% Cell type:markdown id: tags:
+
+Repeat the experiments from Sheet 2, Problem 3, using `strong_greedy` with `orthonormalize=True`.
+
+%% Cell type:markdown id: tags:
+
+## Bonus Problem
+
+%% Cell type:markdown id: tags:
+
+Write a function `word_problem` which, given an arbitrary string, generates a `StationaryProblem` similar to Sheet 1, Problem 2 (c). Each letter should have a corresponding parameter component.
+
+**Hint:** Use the modules `PIL.ImageDraw` und `PIL.ImageFont`.
--- a/rb-intro/problems.py
+++ b/rb-intro/problems.py
+from pymor.basic import *
+
+
+def problem_1_1_a():
+    return StationaryProblem(
+        domain=RectDomain([[0., 0.], [1., 1.]]),
+
+        diffusion=ConstantFunction(1, 2),
+
+        rhs=ExpressionFunction('(sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 1.', 2, ()),
+
+        name='Sheet1_Problem_1a'
+    )
+
+
+def problem_1_1_b():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ConstantFunction(-1., 2),
+
+        diffusion=ExpressionFunction('1. - (sqrt( (x[...,0]-0.5)**2 + (x[...,1]-0.5)**2) <= 0.3) * 0.999', 2, ()),
+
+        name='Sheet1_Problem_1b'
+    )
+
+
+def problem_1_1_c():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ConstantFunction(-1., 2),
+
+        diffusion=ExpressionFunction(
+            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',
+            2, (),
+            values={'K': 10}
+        ),
+
+        name='Sheet1_Problem_1c'
+    )
+
+
+def problem_1_1_d():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ConstantFunction(-1., 2),
+
+        diffusion=BitmapFunction('RB.png', range=[0.001, 1]),
+
+        name='Sheet1_Problem_1d'
+    )
+
+
+def problem_1_2_a():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),
+
+        diffusion=ExpressionFunction(
+            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * 0.999',
+            2, (),
+            values={'K': 10}
+        ),
+
+        parameter_space=CubicParameterSpace({'neum': ()}, -10, 10),
+
+        name='Sheet1_Problem_2a'
+    )
+
+
+def problem_1_2_b():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ExpressionFunction('-cos(pi*x[...,0])**2*neum', 2, (), parameter_type={'neum': ()}),
+
+        diffusion=ExpressionFunction(
+            '1. - (sqrt( (np.mod(x[...,0],1./K)-0.5/K)**2 + (np.mod(x[...,1],1./K)-0.5/K)**2) <= 0.3/K) * (1 - diffu)',
+            2, (),
+            values={'K': 10},
+            parameter_type={'diffu': ()}
+        ),
+
+        parameter_space=CubicParameterSpace(
+            {'neum': (), 'diffu': ()},
+            ranges={'diffu': [0.0001, 1.], 'neum': [-10, 10]}
+        ),
+
+        name='Sheet1_Problem_2b'
+    )
+
+
+def problem_1_2_c():
+    return StationaryProblem(
+        domain=RectDomain(bottom='neumann'),
+
+        neumann_data=ConstantFunction(-1., 2),
+
+        diffusion=LincombFunction(
+            [ConstantFunction(1., 2),
+             BitmapFunction('R.png', range=[1, 0]),
+             BitmapFunction('B.png', range=[1, 0])],
+            [1.,
+             ExpressionParameterFunctional('-(1 - R)', {'R': ()}),
+             ExpressionParameterFunctional('-(1 - B)', {'B': ()})]
+        ),
+
+        parameter_space=CubicParameterSpace({'R': (), 'B': ()}, 0.0001, 1.),
+
+        name='Sheet1_Problem_2c'
+    )
--- a/rb-intro/solutions/Sheet3_Solutions.ipynb
+++ b/rb-intro/solutions/Sheet3_Solutions.ipynb
--- a/rb-intro/solutions/problems.py
+++ b/rb-intro/solutions/problems.py
+../problems.py
\ No newline at end of file