text:
Next: , Previous: Extended streams, Up: Features

### 2.2 Regular expression matching

Regular expressions, or "regexes", are a sophisticated way to efficiently match patterns of text. If you are unfamiliar with regular expressions in general, see Syntax of Regular Expressions, for a guide for those who have never used regular expressions.

gnu Smalltalk supports regular expressions in the core image with methods on String.

The GNU gnu Smalltalk expression library is derived from GNU libc, with modifications made originally for Ruby to support Perl-like syntax. It will always use its included library, and never the ones installed on your system; this may change in the future in backwards-compatible ways. Regular expressions are currently 8-bit clean, meaning they can work with any ordinary String, but do not support full Unicode, even when package I18N is loaded.

Broadly speaking, these regexes support Perl 5 syntax; register groups ()' and repetition {}' must not be given with backslashes, and their counterpart literal characters should. For example, \{{1,3}' matches {', {{', {{{'; correspondingly, (a)(\()' matches a(', with a' and (' as the first and second register groups respectively. gnu Smalltalk also supports the regex modifiers imsx', as in Perl. You can't put regex modifiers like im' after Smalltalk strings to specify them, because they aren't part of Smalltalk syntax. Instead, use the inline modifier syntax. For example, (?is:abc.)' is equivalent to [Aa][Bb][Cc](?:.|\n)'.

In most cases, you should specify regular expressions as ordinary strings. gnu Smalltalk always caches compiled regexes, and uses a special high-efficiency caching when looking up literal strings (i.e. most regexes), to hide the compiled Regex objects from most code. For special cases where this caching is not good enough, simply send #asRegex to a string to retrieved a compiled form, which works in all places in the public API where you would specify a regex string. You should always rely on the cache until you have demonstrated that using Regex objects makes a noticeable performance difference in your code.

Smalltalk strings only have one escape, the '' given by ''', so backslashes used in regular expression strings will be understood as backslashes, and a literal backslash can be given directly with \\'1.

The methods on the compiled Regex object are private to this interface. As a public interface, gnu Smalltalk provides methods on String, in the category regex'. There are several methods for matching, replacing, pattern expansion, iterating over matches, and other useful things.

The fundamental operator is #searchRegex:, usually written as #=~, reminiscent of Perl syntax. This method will always return a RegexResults, which you can query for whether the regex matched, the location Interval and contents of the match and any register groups as a collection, and other features. For example, here is a simple configuration file line parser:

     | file config |
config := LookupTable new.
file := (File name: 'myapp.conf') readStream.
file linesDo: [:line |
(line =~ '(\w+)\s*=\s*((?: ?\w+)+)') ifMatched: [:match |
config at: (match at: 1) put: (match at: 2)]].
file close.
config printNl.

As with Perl, =~ will scan the entire string and answer the leftmost match if any is to be found, consuming as many characters as possible from that position. You can anchor the search with variant messages like #matchRegex:, or of course ^ and $ with their usual semantics if you prefer. You shouldn't modify the string while you want a particular RegexResults object matched on it to remain valid, because changes to the matched text may propagate to the RegexResults object. Analogously to the Perl s operator, gnu Smalltalk provides #replacingRegex:with:. Unlike Perl, gnu Smalltalk employs the pattern expansion syntax of the #% message here. For example, 'The ratio is 16/9.' replacingRegex: '(\d+)/(\d+)' with: '$%1\over%2$' answers 'The ratio is$16\over9\$.'. In place of the g modifier, use the #replacingAllRegex:with: message instead.

One other interesting String message is #onOccurrencesOfRegex:do:, which invokes its second argument, a block, on every successful match found in the receiver. Internally, every search will start at the end of the previous successful match. For example, this will print all the words in a stream:

     stream contents onOccurrencesOfRegex: '\w+'
do: [:each | each match printNl]

#### Footnotes

[1] Whereas it must be given as `\\\\' in a literal Emacs Lisp string, for example.


text:
Electrostatic attraction

1. Jun 10, 2007

Kushal

hi.... actually, i got dust under my ipod screen,,, i've been searching for was to remove it without getting it naked....

so i thought of electrostatic induction.... i thought that, rbbing a pen with my hairs and then approaching it to my screen, the dust particles would be moving at least from the middle of the screen... i've tried it but with no success...

should it be actually working by theory.... btw, the screen is abt 2mm thick.
is there a way to improve what i'm doing?? or is there any suggestion as to remove thye dust without opening the ipod....

2. Jun 10, 2007

lalbatros

tr wth cmprssd r vntll, bt t r wn rsk

3. Jun 10, 2007

esalihm

the plastic screen might be preveting it.
did you try to do anything about induction with a plastic layer in between? if ur charged object is not very strong it cannot overcome the plastic which holds nearly all the charges because

PLASTIC DOES NOT CONDUCT ELECTRICITY

4. Jun 11, 2007

Kushal

hey lallbatros!! was that english??? lol i figured the try with compressed @$^&%^$*^ but try at your own risk??

could you just tell me in a way i'll understand!!! thnx

5. Jun 11, 2007

Kushal

nope, the screen is of glass..... and how can i increase the strength of the charged object...

6. Jun 11, 2007

esalihm

u have an iPod with a glass screen? Is it the original cover or did u replace it with something else?

if it is the original one, I doubt that it is glass...

7. Jun 11, 2007

waht

You might actually destroy the ipod's chip when exposing it to an electrostatic charge.

Just blow the dust with compressed air, that should take care of that.

8. Jun 12, 2007

Kushal

now tat i'm a having a closer look, the screen seems like plastic!! ooopss

and how does this compressed air method work? thnks

format: plain


text:
# Review of Continual Learning at CVPR'20

I review in this article, papers published at CVPR 2020 about Continual Learning. If you think I made a mistake or miss an important paper, please tell me!

## 1. Few-Shots

Many papers this year in Continual Learning were about few-shot learning. Besides the CVPR papers I’ll present, there is also a workshop paper (Cognitively-Inspired Model for Incremental Learning Using a Few Examples, Ayub et al. CVPR Workshop 2020) and an arXiv (Defining Benchmarks for Continual Few-Shot Learning, Antoniou et al. arxiv:2004.11967).

### 1.1. Few-Shot Class-Incremental Learning

PDF: 2004.10956
Authors: Xiaoyu Tao, Xiaopeng Hong, Xinyuan Chang, Songlin Dong, Xing Wei, Yihong Gong

Tao et al. proposes in this paper a mix between Few-Shot and Continual Learning. They benchmark their model —TOPIC– on the CIFAR100, miniImageNet, and CUB200. The first task is large (60 classes for CIFAR100), then the following tasks have few classes (5 ‘n-way’) and few training samples per class (5 ‘k-shots’).

The author uses Neural Gas (Martinetz et al. 1991) and Competitive Hebbian Learning (Martinetz, 1993). This neural network seems similar to the Self-Organizing Maps.

The Neural Gas is an undirected graph, where each node $j$, is defined as $(m_j, \Lambda_j, z_j, c_j)$: - $m_j$ is a centroid vector, similar to what we can expect after a K-Means (kNN for CL) - $\Lambda_j$ is the variance matrix of each dimension of the vector - $z_j$ and $c_j$ are respectively the assigned images and labels

The graph is created after the first task, once the features extractor has been trained. They sample 400 features randomly among the training samples and use them as initial centroids.

Nodes are updated by some kind of moving average (Eq.3 of the paper), where all centroids go towards the incoming sample. The move in the latent space is weighted by a learning rate and more importantly by the L2 distance rank: close features will affect more the centroid than far features.

To create the edges between nodes, they use Competitive Hebbian Learning. Hebbian Learning in Neuroscience stipulates that:

Neurons that fire together, wire together

In this case, if two nodes are respectively the closest and second closest nodes to an input features, an edge is created. The edge has an age that is incremented each time no “firing together” happened. Past an age threshold, the edge is removed.

The model is trained with a usual softmax+cross-entropy but the competitive Hebbian learning is done after each step. Note that the latter doesn’t produce gradients for backpropagation.

Finally, the inference is not really explained but I guess that each node has a “label” by voting which training sample labels were most associated with. Given a test input sample, its label is determined by the label of its closest node.

They stabilize the training by constraining the centroids to stay close to their previous position with a loss they called “anchor loss”. It’s actually a Mahalanobis loss, where the distance is weighted per dimension with the inverse of the variance (i.e. precision).

They also add a regularization called “min-max loss” to separate new centroids (added with new tasks) from previous centroids. It is similar to the hinge loss used by Hou et al. 2019.

### 1.2. Incremental Few-Shot Object Detection

PDF: 2003.04668
Authors: Juan-Manuel Perez-Rua, Xiatian Zhu, Timothy Hospedales, Tao Xiang

Perez-Rua et al. propose to use together three settings: Continual Learning, Object Detection (aka finding object boxes in an image), and Few-Shot (with few training samples).

Their setting is made of a first large task, with many classes & data, then the following tasks add new classes with only 10 labeled examples per class (10 k-shots). This is impressive because object detection is harder than classification!

During the first task, they train a CenterNet. Similar to CornerNet, class-agnostic features are extracted by a ResNet then class-specific heatmaps are generated. The most active zones are chosen to be boxes’ centers. Two additional heads regress the boxes’ width and height.

Once their CenterNet has been trained on the base classes, they train a Meta-Learning-based generator. This module must learn to produce the “class-codes”, aka the class-specific weights used by the detector. To do so, they train the generator on the base classes split into episodes. All weights are frozen except the generator’s.

For the following tasks, there is no training. Given a new class, the meta-generator produces on-the-fly new weights, and the inference is immediately done.

It’s worth noting that the results on novel classes are quite low:

## 2. Conditional Channel Gated Networks for Task-Aware Continual Learning

PDF: 2004.00070
Authors: Davide Abati, Jakub Tomczak, Tijmen Blankevoort, Simone Calderara, Rita Cucchiara, Babak Ehteshami Bejnordi

Abati et al. propose an interesting view of sub-networks in Continual Learning. Previous methods proposed to learn sub-networks inside a unique network (think Lottery Ticket Hypothesis (Frankle & Carbin, 2018)). Those sub-networks can be learned by an evolutionary algorithm (Fernando et al., 2017), L1 sparsity (Golkar et al., 2019), or learned gating (Hung et al., 2019). However they all have a major constraint: they need the task id in inference to choose the right sub-networks, a setting called Multi-Head Evaluation. Having the task id in inference makes the problem much easier, and I think it is not realistic.

The authors propose to train sub-networks with learned gating. The right sub-network will be chosen inference with a Task Classifier, therefore they don’t use the task id! To the best of my knowledge, they are only the second to do this (von Oswald et al. 2020).

Each residual block of their ResNet has $T$ (number of tasks) gate networks that choose the which filters to enable or disable:

The selection of filters to pass or block is discrete and thus non-differentiable. Thus they use the Gumbel Softmax Sampling similarly to (Guo et al. 2019). The forward pass is discrete, but the backward pass is continuous. After each task, they record on a validation set which gates have fired. Their associated filters will be frozen for the following tasks, but still usable!

The interesting part of this paper is how they train the task classifier. During training, all gates are fired in parallel:

This means that given a single input image, they have $T$ parallel stream of activations. All those streams’ outputs are concatenated and fed to a task classifier (a two layers MLP) that classifies the task id. This task id will then be used to chose the right stream to give to the task-specific classifier.

I really like this method, however, it’s unfortunate that they don’t compare their model to the lastest SotA and on large-scale datasets. Their largest dataset is ImageNet-50. Furthermore, I would like to see which gates fire the most, early layers or later layers?…

## 3. Incremental Learning in Online Scenario

PDF: 2003.13191
Authors: Jiangpeng He, Runyu Mao, Zeman Shao, Fengqing Zhu

He et al. claim to learn in an “Online Scenario”: new classes are added as usual, with also old classes new samples. This sounds similar to the New Instances and Classes (NIC) (Lomonaco et al., 2017). They claim novelty while it’s not really true (on top of my head, Aljundi et al. and Lomonaco et al. have worked on this).

The authors propose two contributions: first of all they use at first a Nereast Class Mean (NCM) (kNN for CL) classifier. Similar to iCaRL’s NME, class means are computed. To handle concept drift, they update the means for new samples with a moving average:

$$\mu_{y}^{\phi} \leftarrow \frac{n_{y i}}{n_{y i}+1} \mu_{y}^{\phi}+\frac{1}{n_{y i}+1} \phi\left(\mathbf{x}_{i}\right)$$

Furthermore, during the early tasks, they use in inference their NCM classifier because they remark that it behaves well with data scarcity. When the model is better trained, having seen enough samples, they switch their classifier for the class probabilities from a softmax. It’s interesting to mix those inference classifiers (classification and metric-based) contrary to Hou et al., 2019 and Douillard et al., 2020 that evaluated separately the two methods. However He et al.’s switch from one method to the other is an hyperparameter, it would have been nice to do so based on some Uncertainty measure.

Their second contribution is a modified cross-distillation: in addition of an usual distillation loss on probabilities with temperature (Hinton et al., 2015), they modify the classification loss. It is still a cross-entropy but the probabilities associated to old classes are a linear combination of the old and new model outputs:

$$\tilde{p}^{(i)}=\left\{\begin{array}{cc}\beta p^{(i)}+(1-\beta) \hat{p}^{(i)} & 0 \lt i \leq n \\\ p^{(i)} & n \lt i \leq n+m\end{array}\right.$$

They also finetune their model on a balanced set like Castro et al., 2018 did.

Finally, they evaluate their model on CIFAR100, ImageNet100, and Food-101. Unfortunately, they evaluate their “Online” NIC setting only on Food-101 and solely compare against a simple baseline, not any SotA models (adapted to the setting). CIFAR100 and ImageNet100 are evaluated in the classic NC setting. They have slightly better performance than SotA on the former and are equivalent to BiC on the latter. I’m quite annoyed that they claimed in the abstract to “out-perform” SotA on ImageNet1000 while they actually only evaluate on the smaller-scale ImageNet100. BiC really shines on ImageNet1000, I’d have liked to see how their model fares in this harsher dataset.

## 4. iTAML: An Incremental Task-Agnostic Meta-learning

PDF: 2003.11652
Authors: Jathushan Rajasegaran, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, Mubarak Shah

Rajasegaran et al. propose to a novel Meta-Learning model. Several approaches exist using this branch of methods for Continual Learning, they are however the first to the best of my knowledge to do so without task id in inference.

The goal of Meta-Learning is to “learn to learn”. In this case, they want to obtain a network that learns to produce a set of parameters that can then be tuned quickly to a particular task. Following existing Meta-Learning models, they train in two loops. The inner loop learns an actual task, while the outer loop learns to produce a good initialization for the inner loop (i.e. “learn to learn”). Inspired by Reptile (Nichol et al., 2018), their outer loop is trained on the difference between the base parameters and the parameters learned after the inner loop. The different with Reptile is that the inner loop learns separately each task, producing mean inner loop parameters:

$$\Phi=\Phi_{b a s e}-\eta \frac{1}{t} \sum_{i=1}^{t}\left(\Phi_{b a s e}-\Phi_{i}\right)=\eta \frac{1}{t} \sum_{i=1}^{t} \Phi_{i}+(1-\eta) \Phi_{b a s e}$$

This forces the meta-model to find a set of parameters good for all tasks:

During inference, they proceed in two steps: finding the task id, and then tuning the model for this task. To find the task id, they record for the test subset which task predictions are the most activated in average, and choose the maximum value:

Then, given the predicted task id, they sample all exemplars memory (aka Rehearsal Learning) belonging to this task and learn in a single inner loop task-specific parameters. The resulting model is then used to classify the test samples.

Note that while it’s a very interesting approach, their model stands on the quality of the task classification. They claim it’s almost 100% accuracy but it only for a reason: in their setting, the model is evaluated on each seen task separately. In a real setting, samples from different tasks are mixed together. There their algorithm 2 won’t work. Therefore I don’t think this model is truly “task-agnostic” but it’s definitely a good step forward.

They evaluate various models, from meta-learning to continual learning domains, on MNIST, SVHN, CIFAR100, ImageNet100, ImageNet1000, and Celeb-10k. It’s a bit strange however that BiC (a very good alternative for large scale datasets) is evaluated on Celeb-10k but not ImageNet100 (where it would have beaten iTAML).

## 5. Modeling the Background for Incremental Learning

PDF: 2002.00718
Authors: Fabio Cermelli, Massimiliano Mancini, Samuel Rota Bulò, Elisa Ricci, Barbara Caputo

Cermelli et al. attacks the problem of Semantic Segmentation for Continual Learning. In semantic segmentation, the goal is to give a class to each pixel. Two cars next to each other will have the same pixels labels. This is particularly difficult in Continual Learning for the same reasons as Object Detection: at task $t$, the class “car” may be a background, but then at task $t+1$ we have to predict it. However, our model may have seen images containing cars in the first task and thus has learned to not detect those. Likewise, images from task $t+1$ may be annotated so that the “person” learned previously is now part of the background.

To solve the problem mentionned before, they revisit both the cross-entropy and distillation losses. The former is split in two part: if the pixel probability belongs to the current task’s set of classes it is kept unchanged. Otherwise, it is the probability of having either an old class or the background:

$$\begin{array}{l}\qquad \ell_{c e}^{\theta^{t}}(x, y)=-\frac{1}{|\mathcal{I}|} \sum_{i \in \mathcal{I}} \log \tilde{q}_{x}^{t}\left(i, y_{i}\right) \\\ \text { where: } \\\ \qquad \tilde{q}_{x}^{t}(i, c)=\left\{\begin{array}{ll}q_{x}^{t}(i, c) & \text { if } c \neq \mathrm{b} \\\ \sum_{k \in \mathcal{Y}^{t-1}} q_{x}^{t}(i, k) & \text { if } c=\mathrm{b}\end{array}\right.\end{array}$$

Likewise, the distillation loss is changed if the pixel belongs to the background, according to the current task, to the probability of having either a new class or the background:

$$\ell_{k d}^{\theta^{t}}(x, y)=-\frac{1}{|\mathcal{I}|} \sum_{i \in \mathcal{I}} \sum_{c \in \mathcal{V} t-1} q_{x}^{t-1}(i, c) \log \hat{q}_{x}^{t}(i, c)$$

$$\hat{q}_{x}^{t}(i, c)=\left\{\begin{array}{ll}q_{x}^{t}(i, c) & \text { if } c \neq \mathrm{b} \\\ \sum_{k \in \mathcal{C}^{t}} q_{x}^{t}(i, k) & \text { if } c=\mathrm{b}\end{array}\right.$$

This handles the case where the previous model considers a current pixel as background while the current model considers it as a new class.

Finally, the classifier weights for new classes are initialized with the background weight.

## 6. ADINET: Attribute Drive Incremental Network for Retina Image Classification

PDF: CVPR webpage
Authors: Qier Meng, Satoh Shin’ichi

Meng and Shin’ichi use Continual Learning for retinal images classification. They found that retinal diseases have a large variety of types and that current methods didn’t allow them to train incrementally each type a new patient came in.

Their originality lies in their usage of attributes. Retinal images have been annotated with a disease label (“AMD”, “DR”…) but also with several attributes (“hermorrhage”, “macular edema”…). Therefore in addition to the classic distillation loss with temperature scaling applied to the disease prediction, they also distill the attributes prediction of the previous model with a BCE.

In addition to the two distillation losses, they also refine their attributes prediction with a “weight estimation”. It measures how much of a contribution an attribute has to distinguish classes. It’s similar to doing a self-attention on all attributes to find which one is the most important. This weight estimation is then used to ponder the attribute predictions. They didn’t detail much the rationale behind this weight estimation but empirical results show small but consistent gains.

They evaluate both medical and academic datasets. For the later they used ImageNet-150k-sub: it contains 100 classes of ImageNet1000, but only 150 training images were selected per class instead of ~1200. I’ve never seen a model evaluated on this dataset, but it looks like a more challenging dataset than ImageNet100. They display a significant improvement over the 2017’s iCaRL.

It’s interesting to predict attributes in the context of Continual Learning. I hypothesize that it forces the model to learn fine-grained features common to all tasks and may reduce catastrophic forgetting.

## 7. Semantic Drift Compensation for Class-Incremental Learning

PDF: 2004.00440
Authors: Lu Yu, Bartłomiej Twardowski, Xialei Liu, Luis Herranz, Kai Wang, Yongmei Cheng, Shangling Jui, Joost van de Weijer

Rebuffi et al., 2017 uses class means with a k-NN to classify samples in inference. Those class means are updated after each task by re-extracting features of rehearsal samples of old classes with the new ConvNet. This supposes that we have access to previous data, at least in a limited amount.

Yu et al. propose to update the class means without even using previous data. First, they compute the embedding drift between the start and the end of the current task on current data:

$$\boldsymbol{\delta}_{i}^{t-1 \rightarrow t}=\mathbf{z}_{i}^{t}-\mathbf{z}_{i}^{t-1}, y_{i} \in C^{t}$$

Then for each old classes, they compute the mean vector of drift:

$$\begin{array}{c}\hat{\Delta}_{c^{s}}^{t-1 \rightarrow t}=\frac{\sum_{i}\left[y_{i} \in C^{t}\right] w_{i} \delta_{i}^{t-1 \rightarrow t}}{\sum_{i}\left[y_{i} \in C^{t}\right] w_{i}} \ w_{i}=e^{-\frac{\left|x_{i}^{t-1}-\mu_{c^{s}}^{t-1}\right|^{2}}{2 \sigma^{2}}}\end{array}$$

The drift is weighted by $w_i$, which gives a lower weight to outliers. Thus samples will low confidence won’t affect as much the drift computation than “archetypal” samples.

Finally this drift is computed at after each task, starting from the second one, and is added continuously to the class mean vectors:

$$\hat{\mu}_{c^{s}}^{t}=\mu_{c^{s}}^{s}+\hat{\Delta}_{c^{s}}^{s \rightarrow s+1}+\ldots+\hat{\Delta}_{c^{s}}^{t-1 \rightarrow t}$$

They add their method, nicknamed SDC, to the model EWC. They show on CIFAR100 and ImageNet100 excellent performance only beaten by Hou et al., 2019. It’s important to note that Hou et al., 2019 use exemplars while Yu et al. don’t. On the other hand, according to their code they are in a Multi-Head Evaluation setting where they know the task id during inference. Thus they classify a sample among the task classes instead of all seen classes as do Rebuffi et al., 2017 or Hou et al., 2019. Their setting is not really comparable to Hou et al., 2019.

## 8. Maintaining Discrimination and Fairness in Class Incremental Learning

PDF: 1911.07053
Authors: Bowen Zhao, Xi Xiao, Guojun Gan, Bin Zhang, Shutao Xia

Zhao et al. propose a method directly in the line of Belouadah and Popescu, 2019) (IL2M) and Wu et al., 2019) (BiC). Both works remarked that a bias towards new classes and detrimental to old classes. IL2M uses some statistics to correct this bias, while BiC recalibrates (Recalibration) the probabilities using a linear model learned on validation data.

Zhao et al. use a simpler solution that they call Weight Aligning (WA). They saw, as Hou et al., 2019, that the norm of the weights associated with old classes is lower than those associated with new classes:

Hou et al., 2019 and Douillard et al., 2020 use a cosine classifier so that all norms are equal to 1. Zhao et al. instead re-normalize the weights based on the norm ratio:

$$\begin{array}{c}\widehat{\mathbf{W}}_{n e w}=\gamma \cdot \mathbf{W}_{n e w} \\\ \text { where } \\\ \gamma=\frac{M e a n\left(N o r m_{o l d}\right)}{M e a n\left(N o r m_{n e w}\right)}\end{array}$$

They remark that:

[…] we only make the average norms become equal, in other words, within new classes (or old classes), the relative magnitude of the norms of the weight vectors does not change. Such a design is mainly used to ensure the data within new classes (or old classes) can be separated well.

This weight alignment is done between each task. Furthermore, they clip after each optimization step the value of the weights to be positive to make the weights norm more consistent with their corresponding logits (after ReLU).

In their ablation, they show that weight alignment provides more gain than knowledge distillation which is quite impressive. Using both lead them to a significant gain over BiC and IL2M on large scale datasets like ImageNet1000.

Overall I liked their method as it is very simple and yet efficient.

## 9. Mnemonics Training: Multi-Class Incremental Learning without Forgetting

PDF: 2002.10211
Authors: Yaoyao Liu, An-An Liu, Yuting Su, Bernt Schiele, Qianru Sun

Liu et al. propose in this work two important contributions which make it my favorite paper in this review. The first, advertised, is an improvement of Rehearsal Learning. The second, a little hidden in the paper, is Meta-Learning-inspired method to adapt gracefully to new distribution.

In rehearsal learning, we feed old samples to the model to reduce forgetting. Obviously, we won’t use all old samples, but a very limited amount. Here the authors use 20 images per class, like Hou et al., 2019 and Douillard et al., 2020. Rebuffi et al., 2017 proposed with iCaRL to a herding selection which finds iteratively the barycenter of the class distribution. However Castro et al., 2018 remarked that taking the closest samples to the class mean, or even random samples (!), worked as well.

Liu et al. significantly improve those solutions by transforming the selected exemplars. First, they randomly select samples, then given a trained & fixed model, they optimize the exemplars as the pixel-level:

The optimized exemplars must lead to a decreased loss on the new classes data (present in large amounts).

The modification is very minor visually: we only see a little bit of noise overlayed on the original images. The authors found that this optimization of the images leads to a set of exemplars well distributed on the class boundaries:

This optimization is done at the task end, once exemplars from new classes have been selected. The authors also choose to finetune the exemplars of old classes that have been selected in previous tasks. However, in this case, we don’t have anymore a large amount of old classes’ data to act as ground truth for the old classes exemplars optimization. Therefore, they split the exemplars set in half. One split is optimized using the second for ground truth and vice-versa.

The second contribution, and the major one, is unfortunately not very advertised in this paper. The authors re-use an idea from one of their previous papers in Meta-Learning. Instead of tuning all the ConvNet parameters for each task, they only slightly adapt them: for each kernel, a small kernel of spatial dimensions equal to one is learned (likewise for the biases). This small kernel is expanded to the base kernel dimension and element-wise multiplied to it:

Intuitively, this method called “Meta-Transfer” does a small “shift & scaling”. Most of the network is kept frozen and thus don’t forget too much. The small adaptation enables the network to learn new classes.

They evaluated CIFAR100, ImageNet100, and ImageNet1000 in various settings and beat all previous SotA (especially Hou et al., 2019 and Wu et al., 2019). In my recent paper (Douillard et al., 2020), our model PODNet outperforms their’s in several settings and evaluate even on even longer incremental training.

## 10. Towards Backward-Compatible Representation Learning

PDF: 2003.11942
Authors: Yantao Shen, Yuanjun Xiong, Wei Xia, Stefano Soatto

This paper is not directly related to Continual Learning but rather to Visual Search. Shen et al. raise the issue of backfilling:

On a visual search model, embeddings of a large gallery have been computed once. Then given a query image, we extract its features and compare them to the gallery features collection. For example, I take a picture of a shirt and want to know what are the most similar clothes available in a store.

A problem arises when a new model is trained. This model may be different from the previous one because the data is was trained on or because the architecture and losses were changed. The gallery features collection is not up-to-date anymore and we need to extract gain the features of the whole collection with the new model. This can be very costly when the gallery is made of billions of images.

The authors propose to make the features extractor “backward-compatible”. It’s mean that query features extracted by the new model are in the same latent space of the old model:

To produce a new model backward-compatible with a previous model that may be different, the authors add a loss over the classification loss:

The first part of the loss update the new model on new $t$ dataset $T_{\text{new}}$. For the second part, the best alternative proposed is training the old classifier $w_{c\,\text{old}}$ with the new features extractor $w_\theta$ on the new dataset $T_\text{new} = T_\text{BCT}$. Because the new dataset can contain new classes, the old classifier is extended with new weights. They are initialized with the mean features extracted by $w_{\theta\, \text{old}}$ like Weight Imprinting did in Metric-Learning (Qi et al., 2018).

Overall, their model is still far from the upper-bound (recomputing the gallery with the new model) but they improve significantly over simple baselines and beat LwF (Li & Hoiem, 2016) by 3 points. I think this model is quite “simple” compared to SotA Continual Learning but it is interesting to see actual applications of the domain.


text:
# Version 2.0 API Transition Guide

One of the major changes in 2.0 is a restructuring of the API. In 1.4, most of the functionality of the API was in a single module, ScriptInterface. In 2.0, the API has been subdivided, and some methods have been replaced by new techniques for accomplishing similar tasks. This page runs down the list of methods in 1.4’s ScriptInterface and tells you how to perform the equivalent task in 2.0.

### CompatibilityInterface, AcquisitionManager, Application, and PositionListManager

First, note that the CompatibilityInterface, AcquisitionManager, Application, and PositionListManager modules contain many old methods from ScriptInterface, unmodified. These methods work as they did in 1.4, and include the following:

You can access the CompatibilityInterface by calling the Studio’s () compat method, the AcquisitionManager by calling the Studio’s () acquisitions method, the Application by calling the Studio’s () app method, and the PositionListManager by calling the Studio’s () positions method. The Studio in turn is available in the BeanShell window as “mm”, and is provided to plugins when they are initialized.

### acquisitionExists

In 1.4, Micro-Manager maintained a registry of all “open” datasets (a.k.a. acquisitions), using a unique string key for each one. In 2.0, such a registry no longer exists. Any code that creates a new Datastore (the 2.0 equivalent to a 1.4 acquisition) is responsible for holding onto references to it, destroying it, recreating it, etc.

It is theoretically possible to find Datastores by way of their DisplayWindows, the windows that show images from the Datastore. You can ask the DisplayManager for a list of all DisplayWindows, and ask each DisplayWindow for its Datastore using the getDatastore method. However, remember that Datastores are not required to have any DisplayWindows (and also that it is possible to have multiple DisplayWindows for a single Datastore). If you really need your code to find a Datastore created by someone else’s code, then you should find a better way for the two components to talk to each other.

In 2.0, third-party code is responsible for maintaining its own Datastores (the rough equivalent of 1.4 acquisitions), and can freely add images to Datastores themselves using the putImage method.

This method was used as part of 1.4’s day/night system for enabling low-contrast displays for use in darkrooms. 2.0 uses a different system that works automatically across the entire program; there is no need for individual components to register themselves. Thus this method is obsolete.

### addMMListener / removeMMListener

These methods allowed code to listener for code event callbacks by implementing the MMListener interface, which is no longer in the API in 2.0. Instead, you can listen for events that correspond to each of the callbacks (for example, PropertyChangedEvent instead of the old propertyChangedAlert method), by using 2.0’s event publishing system. Remember to annotate the method that listens to the event, with a Subscribe annotation, and to register your object for event notifications via the EventManager accessible via () Studio.events().

The “album” Datastore is now available via the Studio’s () album method, and you can freely add images to it yourself (see the addImageToAcquisition notes above)

### autostretchCurrentWindow

You can now autostretch individual DisplayWindows using their autostretch method. Thus this method can be replaced by calling displays().getCurrentWindow().autostretch().

### clearMessageWindow

This method was moved to the ScriptController object accessible via the Studio’s () scripter method.

### closeAcquisition

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains responsibility for all open datasets. If you want to clean up a Datastore, you must remove all references to that Datastore from memory. Micro-Manager will not maintain open references itself except via any DisplayWindows you may have requested be created. You can close all open DisplayWindows for a given Datastore via the DisplayManager’s closeDisplaysFor method.

### closeAcquisitionWindow

See the notes on closeAcquisition, above.

### closeAllAcquisitions

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains a listing of all “acquisitions”. Third-party code can freely create new Datastores and Micro-Manager will not be able to “see” them. Thus this method is impossible to implement in 2.0.

However, if you just want to clean up the UI, then the DisplayManager has a closeAllDisplayWindows method.

### createAcquisition

You can request your own new Datastores (the rough equivalent of 1.4 acquisition objects) via the DataManager’s various “createDatastore” methods (e.g. () createRAMDatastore, createMultipageTIFFDatastore, and createSinglePlaneTIFFSeriesDatastore).

### displayImage

This has been replaced by DisplayManager’s show method. Note that this method creates a new Datastore to store the image in. The old behavior of showing images in the Snap/Live Window is no longer possible.

### enableLiveMode

This has been replaced by SnapLiveManager’s setLiveMode method. You should also be aware of the setSuspended method if you need to briefly stop live mode, only to resume it later.

### enableRoiButtons

This method was removed because it is unused by all known third-party code.

### getAcqDlg

This method was deprecated in 1.4, and has been removed in 2.0.

### getAcquisition

This method was deprecated in 1.4 and has been removed in 2.0.

### getAcquisitionPath

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

You can access the save path for a Datastore via its () getSavePath method.

### getAcquisitionImageBitDepth

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Image bit depth is now a property of the Image objects in the Datastore, and is theoretically not required to be the same for all Images in that Datastore (though in practice we do not expect varying bit depths to work right now). You can get the bit depth for an Image by asking for its Metadata (via the () getMetadata method) and then calling the Metadata’s () getBitDepth method.

If you need to get a single image out of a Datastore, you can call its () getAnyImage method.

### getAcquisitionImageByteDepth

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Image byte depth is now a property of the Image objects in the Datastore, and is theoretically not required to be the same for all Images in that Datastore (though in practice we do not expect varying byte depths to work right now). You can get the byte depth for a single image by calling its () getBytesPerPixel method.

If you need to get a single image out of a Datastore, you can call its () getAnyImage method.

### getAcquisitionImageCache

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

The Datastore functions as the equivalent of 1.4’s image cache. You can ask it for images using its getImage method.

### getAcquisitionImageHeight

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Image height is now a property of the Image objects in the Datastore, and is theoretically not required to be the same for all Images in that Datastore (though in practice we do not expect varying image heights to work right now). You can get the height for a single image by calling its () getHeight method.

If you need to get a single image out of a Datastore, you can call its () getAnyImage method.

### getAcquisitionImageWidth

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Image width is now a property of the Image objects in the Datastore, and is theoretically not required to be the same for all Images in that Datastore (though in practice we do not expect varying image widths to work right now). You can get the width for a single image by calling its () getWidth method.

If you need to get a single image out of a Datastore, you can call its () getAnyImage method.

### getAcquisitionMultiCamNumChannels

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

In 2.0 this method is not available. You may try to replicate it by comparing the number of channels in the Datastore (via its getAxisLength method) to the number of unique cameras declared by the Metadatas of the various images (see () Metadata.getCamera). You can iterate over all images in the Datastore via the () getUnorderedImageCoords method combined with the getImage method.

### getAcquisitionPath

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

The path of a Datastore’s saved location on disk is accessible via its () getSavePath method.

### getBackgroundColor

As discussed in the notes for addMMBackgroundListener, background color selection is now handled automatically. Thus this method is no longer needed. However, if you need to manually set colors for the few edge cases where colors are not handled automatically, you should investigate the ApplicationSkin module.

### getBackgroundStyle

This method was replaced by the ApplicationSkin.getSkin method.

### getCacheForWindow

This has been replaced by the DisplayWindow’s () getDatastore method.

### getCurrentAlbum

The Album Datastore can be accessed via the Studio’s () album method.

### getMMCore

The Micro-Manager Core object can be accessed via the Studio’s () core method.

### getROI

Use the Core’s () getROI method.

### getSnapLiveWin

This has been replaced by the SnapLiveManager’s () getDisplay method. You can access the SnapLiveManager via the Studio’s () live method.

Please note that the snap/live display is prone to being destroyed and recreated. It is not recommended that you keep references to the snap/live window in memory; request it anew each time you need it.

### getUniqueAcquisitionName

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Consequently, there is no need to generate unique acquisition names.

### getXYPosListDlg

This method was deprecated in 1.4 and has been removed in 2.0

### getXYStageName

This information can be accessed via the Core’s () getXYStageDevice method. The Core in turn can be accessed via the Studio’s () core method.

### initializeAcquisition

The metadata set by this method is now handled automatically when images are saved; consequently, it is no longer needed.

### installAutofocusPlugin

AutofocusPlugins should now be compiled and annotated with the @Plugin annotation (as described in MMPlugin). If this is done and the resulting jar file is included in the mmautofocus directory of your ImageJ installation, then the plugin will automatically be detected at runtime. There is no mechanism for loading a plugin after µManager’s initialization has completed.

### isLiveModeOn

This method has been replaced by the SnapLiveManager’s isLiveModeOn method. The SnapLiveManager in turn can be accessed via Studio’s live method.

Note that if you just want to temporarily suspend live mode, to resume it later, then you can make use of the SnapLiveManager’s setSuspended method.

### logError

Replaced by the LogManager’s logError method (and similarly for the variants on this method). The LogManager can be accessed via the Studio’s () logs method.

### logMessage

As with logError, replaced by the LogManager’s logMessage method.

### logStartupProperties

This method was removed as it is unused by all known third-party code.

### message

Replaced by the ScriptController’s message method. The ScriptController in turn can be accessed via the Studio’s () scripter method.

### openAcquisition

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

You can request new Datastores via the DataManager’s various “createDatastore” methods (e.g. () createRAMDatastore, createMultipageTIFFDatastore, and createSinglePlaneTIFFSeriesDatastore). If you use a file-backed Datastore, then images will automatically be saved to disk as you add them to the Datastore, though you should make certain to call the Datastore’s () freeze method when you are done to ensure that saving completes successfully.

If you wish to view the images in the Datastore, use the DisplayManager’s createDisplay method. The DisplayManager in turn can be accessed via the Studio’s () displays method.

In any case, there is no need to specify the dimensionality of the dataset ahead of time as was the case with openAcquisition

### openAcquisitionData

Replaced by DataManager’s loadData method. The DataManager in turn can be accessed via the Studio’s () data method.

### promptToSaveAcquisition

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Replaced by the Datastore’s save method.

### registerForEvents

Moved to the EventManager, which can be accessed via the Studio’s () events method.

### removeMMBackgroundListener

As discussed in addMMBackgroundListener above, day/night changes now happen automatically, so this method is obsolete.

### saveConfigPresets

While this method still exists (as part of the Application module), it now two parameters: a path string to save the config to, and a boolean for whether to allow overwriting of existing files. The old functionality that displayed a save dialog has been removed.

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

As you now have complete control over adding images to your Datastores, it is up to you to implement asynchronous image-adding if you need it.

### setAcquisitionProperty

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Arbitrary metadata storage is available for both SummaryMetadata and individual image Metadata via their respective userData fields.

### setBackgroundStyle

This method was replaced by the ApplicationSkin.setSkin method.

### setChannelColor

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in. Likewise, you are responsible for keeping track of any associated DisplayWindows open for a given Datastore. However, for managed Datastores, you can request all open DisplayWindows via the DisplayManager’s getDisplays method.

Channel color is a property of the DisplaySettings for a given DisplayWindow. You can create a new DisplaySettings with adjusted channel colors (e.g. by using the () copy method), and then cause a DisplayWindow to use the new channel color via its setDisplaySettings method.

The above logic relies on you understanding the use of Builder patterns. See Using_Builders for more information.

### setChannelContrast

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in. Likewise, you are responsible for keeping track of any associated DisplayWindows open for a given Datastore. However, for managed Datastores, you can request all open DisplayWindows via the DisplayManager’s getDisplays method.

Channel contrast settings are properties of the DisplaySettings for a given DisplayWindow. You can create a new DisplaySettings with adjusted contrast (e.g. by using the () copy method), and then cause a DisplayWindow to use the new channel color via its setDisplaySettings method.

The above logic relies on you understanding the use of Builder patterns. See Using_Builders for more information.

### setChannelName

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Channel names are a property of the SummaryMetadata associated with a given Datastore. You can access the SummaryMetadata using the Datastore’s () getSummaryMetadata method, make a copy with the () copy method, adjust the channel names to suit, and then cause the Datastore to use the new summary metadata using the setSummaryMetadata method.

The above logic relies on you understanding the use of Builder patterns. See Using_Builders for more information.

### setContrastBasedOnFrame

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in. Likewise, you are responsible for keeping track of any associated DisplayWindows open for a given Datastore. However, for managed Datastores, you can request all open DisplayWindows via the DisplayManager’s getDisplays method.

This method is not available in 2.0. However, you can replicate its functionality for a given DisplayWindow by combining the SetDisplayedImageTo method of DisplayWindow and the shouldAutostretch field of the DisplaySettings.

### setConfigChanged

This method was removed as it is unused by all known third-party code.

### setImageProperty

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.

Arbitrary metadata storage is available for both SummaryMetadata and individual image Metadata via their respective userData fields.

### setImageSavingFormat

When saving the contents of a Datastore, you must specify the format you want to use in the form of a Datastore.SaveMode. Alternately, if you want to show the user a save-file dialog, then that dialog will include a file format dropdown menu that they can use to decide which format to use. The dropdown menu (and the MDA dialog’s save-files section) will automatically default to the format the user last used to save files.

### setRelativeStagePosition

This functionality be accessed via the Core’s () setRelativePosition method. The Core in turn can be accessed via the Studio’s () core method.

### setRelativeXYStagePosition

This functionality can be accessed via the Core’s () setRelativeXYPosition method. The Core in turn can be accessed via the Studio’s () core method.

### setStagePosition

This functionality can be accessed via the Core’s () setPosition method. The Core in turn can be accessed via the Studio’s () core method.

### setXYOrigin

This functionality can be accessed via the Core’s () setOriginXY method. The Core in turn can be accessed via the Studio’s () core method.

### setXYStagePosition

This functionality can be accessed via the Core’s () setXYPosition method. The Core in turn can be accessed via the Studio’s () core method.

### showError

Moved to the LogManager object, which can be accessed via the Studio’s logs method.

### showMessage

Moved to the LogManager object, which can be accessed via the Studio’s logs method.

### showXYPositionList

For consistency, this method was renamed to () showPositionList in PositionListManager.

### sleep

This method has been removed. Use Thread.sleep instead.

As discussed in the notes on acquisitionExists, above, Micro-Manager no longer maintains records on any acquisition objects; you are responsible for maintaining your own references to the Datastore that your data is in.


text:
# Derivatives and SA

1. Sep 12, 2003

### Gale

in my calc class, someone noticed that when you take the derivative of the formula for volume of a circle, it becomes the formula for the surface area. anyone know why? and what other shapes is this also true for?

2. Sep 12, 2003

### chroot

Staff Emeritus
It's because the volume of a sphere can be found by integrating the surface area of spherical shells from the center to the surface.

Integrate[4 Pi r^2, {r, 0, R}] = 4/3 Pi R^3

It works for any shape. An area integrated over a third dimension is a volume.

For a cube, the integral looks like:

Integrate[6 Sqrt[2] s^2, {s, 0, (Sqrt[2]/2) R}] = R^3

- Warren

3. Sep 12, 2003

### HallsofIvy

Staff Emeritus
It is also true that the derivative of the Area of a circle:
[pi]r2 (with respect to r) is the circumference (2[pi]r).

That's basically because, as Chroot said, that you can find the volume a sphere by integrating the surface area of "nested" spheres or the area of a circle by integrating the circumference of "nested" circles.

4. Sep 12, 2003

### Gale

damn well, too bad i don't know what integrating is... i'm not that far into calc, but i guess i can tell my teacher that at any rate. also, what other shapes, aside from circles. i think he said something about cones... or conics... or something, i missed it.

5. Sep 12, 2003

### Hurkyl

Staff Emeritus
Any surface that, when applying a coating of paint with uniform thickness, is (sufficiently close to) the same kind of surface.

6. Sep 12, 2003

### Gale

umm... i have no clue what that means...
and since we're on the subject of my having no clue... what is this 'nesting of spherical shells'

7. Sep 13, 2003

Staff Emeritus
Like layers of an onion. There is an outside sphere, just a thin shell, and inside that is another shell whose outside surface exactly coincides with the inside surface of the first one. And ... so on... one shell inside another till you get to the center. These shells all have the same finite thickness. And then you think of having twices as many shells, each half as thick. And ... so on ... till in the limit of the thickness going to zero you recover the volume of the solid ball .

8. Sep 13, 2003

### lethe

this result also follows from stoke s theorem, one of my favorite theorems.

9. Sep 14, 2003

### krab

Here's the connection: If you paint a sphere, then the volume of paint used is the surface area times the thickness of the paint layer. Or, another way to put it is that the surface area is the volume of paint (dV) divided by the thickness of paint (dr); S=dV/dr.

This works because for a sphere, the thickness of paint is an increment in radius. It wouldn't work for, say, a cube when its volume is epressed in terms of the length of a side: V=a^3, but S is not 3a^2. However, if you write the volume of a cube in terms of _half_ a side's length h=a/2, then V=8h^3 and S is indeed 24h^2.

10. Sep 14, 2003

### phoenixthoth

"Like layers of an onion. There is an outside sphere, just a thin shell, and inside that is another shell whose outside surface exactly coincides with the inside surface of the first one. And ... so on... one shell inside another till you get to the center. These shells all have the same finite thickness. And then you think of having twices as many shells, each half as thick. And ... so on ... till in the limit of the thickness going to zero you recover the volume of the solid ball ."

these layers have infinitesimal thickness, right?

cheers,
phoenix

11. Sep 14, 2003

### Hurkyl

Staff Emeritus
An example of something with which this will not work is in order...

ellipses and other conic sections are good example; if you paint an ellipse (with an even thickness), the result is not an ellipse.

12. Sep 14, 2003

Damn you all, thats all I can ever think about when I'm painting!

13. Sep 14, 2003

### Gale

thanks, i understand now i think. i'll double check in class tomorrow. whats is stokes theorem?

14. Sep 15, 2003

### Gale

ok, i didn't understand your answers well enough to explain to my teacher, who by the way, is a wicked pain in the ass, and won't just tell me. so, could some one either explain this a different way or tell me where i could find out or something.

also: i just realized i worded my first question wrong, i said circle, i meant sphere. when you take the derative from the formula for the volume of a shere, you get the formula for it's surface area. i need to know why this is, and what shapes it holds true for, and also why?

15. Sep 15, 2003

### chroot

Staff Emeritus
Since a circle doesn't have a volume, I automatically assumed you actually meant sphere. All our responses are appropriate to the sphere.

Did you not read the responses? Or did you just not understand them?

Let's say you start with a tiny little ball bearing -- one so small that its volume is negligible.

You then paint a very thin layer of paint around the ball bearing. Then you add another layer, and another layer, and so on, until you have a baseball sized sphere. The volume is made up of many layered spherical shells of paint. You can imagine that the thickness of each of the layers is so small that they are essentially two-dimensional surfaces.

The volume of the sphere can be easily imagined to be composed of an infinite number of infinitely thin layers of paint. The surface area of each layer is 4 pi r^2. The integral (sum) of the layers is a volume, 4/3 pi R^3. (r is an internal radius, R is the radius of the outermost surface.)

If the integral of 4 pi r^2 (dr) from 0 to R (from the center to the outside of the sphere) is 4/3 pi R^3, then the converse is also true: the derivative of 4/3 pi R^3 is 4 pi r^2.

As has been mentioned, this method works for any volumes that can be built out of such layers of paint.

- Warren

16. Sep 15, 2003

### Gale

ah thanks, i was only sort of half understanding your answers. i read them, and understood what they said, but not how they related to the math i guess. would you believe that the little peice of understanding i kept missing was that the "layers of paint" were '2 dimensional' or individual sort of surface areas. i get it now though, i was just dense.

17. Sep 16, 2003

### lethe

stokes theorem says that for any space, of any dimension, the integral of some object on the boundary of that object equals the integral of the derivative of that object.

this breaks down into many familiar special cases, the fundamental theorem of calculus, the divergence theorem, the curl theorem for line integrals, the gradient theorem, and many higher dimensional generalizations.

the boundary of a filled ball is the sphere, so stokes theorem makes this relationship trivial to prove, along with many generalizations of it.


text:
# Kernel of Group Action

this is my first post here.
I have a question regarding a proof in Algebra by Hungerford:

Let $G$ be a group and $H$ a subgroup of $G$. Let $S$ be the set of all cosets of $H$, where $G$ acts on $S$.
Chapter II Collorary 4.9: "$\dots$ the kernel of $G \rightarrow A(S)$ is a normal subgroup of $G\dots$" Question: Why is the kernel normal?

I looked through the chapter but there were no references, so I figure this is probably "obvious" and hence not included. I came up with an attempt at the proof:

Let $K$ be the kernel of the action.
$ex = x \implies e\in K \implies K$ contains identity.
Let $a,b\in K$.
$(ab)x=a(bx) = ax=x \implies ab\in K \implies K$ is closed.
$a\in K \implies ax=x\implies x=a^{-1}x\implies a^{-1}\in K\implies$ all elements in $K$ has an inverse.
Hence $K$ is a group.

Let $g\in G$.
$(gKg^{-1})x=(gK)(g^{-1}x)=g(K(g^{-1}x))=g(g^{-1}x)=x\implies gKg^{-1}\subset K$
Substitute $g$ for $g^{-1}$ and we get $K\subset gKg^{-1}$.
Hence $gKg^{-1}=K$ and $K$ is normal.

Is this approach correct?

Also, suppose we were to consider the isotropy group of an element $x\in G$ instead.
i.e. $G_x=\lbrace g\in G\mid gx=x\rbrace$
$G_x$ will be a subgroup of $G$ using a similar argument, but now it is not guaranteed to be a normal subgroup because in
$(gG_xg^{-1})x=g(G_x(g^{-1}x))$,
$G_x(g^{-1}x)=g^{-1}x$ is not necessary true.
Is this argument right?

-
I was unable to tag it as (textbooks) and unable to put "Hi everyone!"... Not sure what is the error, my apologies. –  Yong Hao Ng Aug 7 '12 at 18:57
MSE deliberately prevents greetings, salutations, and some "thank yous" and whatnot. But hi to you too, and welcome to the forum! –  mixedmath Aug 7 '12 at 18:58
Thanks for the clarification. –  Yong Hao Ng Aug 7 '12 at 19:18

Alternatively, notice that an action is really given by a group homomorphism $G\rightarrow \operatorname{Perm}(S)$ into group of permutations of $S$. Then the kernel of the action is nothing but the kernel of this map, and a kernel of a homomorphism is always normal.
The reason the kernel is normal is because given any group homomorphism $\varphi :G\to G'$, the kernel of $\varphi$ is a normal subgroup of $G$, and the way to prove this is exactly the way you did.


text:
# Would the same equilibrium concentration of carbon dioxide, carbon monoxide and oxygen always result for a given initial atomic carbon fraction?

Chemistry SE Question: Starting with a gas mixture of some combination of gases containing carbon and oxygen with a total carbon atomic fraction $$f$$, would it always reach the same equilibrium proportions of $$\ce{CO2 + O2 + CO}$$?

For example if I had an equal number of $$\ce{CO2}$$ and $$\ce{O2}$$ molecules then $$f=0.2$$, but so would two molecules of $$\ce{CO2}$$ for every three molecules of $$\ce{O2}$$. If I started with either mixture in this example, would I end up with the same equilibrium mixture of $$\ce{CO2}$$ and $$\ce{CO}$$ and $$\ce{O2}$$?

Simplifying assumptions: Assume $$\pu{273K}$$ and $$\pu{610Pa}$$ if necessary, the answer may be as simple as "yes it would" or "no it wouldn't, because...", a supply of ionizing radiation from space (hard UV and energetic cosmic ray particles) and a billion years, and ignore transmutation of elements by those particles.

Background and motivation is from my Space Exploration SE question Are Mars' atmospheric CO₂, O₂ and CO in equilibrium? Are sunlight or chemical reactions involved?, which begins:

According to the NASA JPL video linked below the top five gases comprising the martian atmosphere include $$\ce{CO₂, O₂}$$ and $$\ce{CO}$$. Do the proportions reflect some chemical equilibrium? Are sunlight or chemical reactions involved in maintaining these proportions?

Component     Fraction
CO2          95.9%
Ar            2.0%
N2            1.9%
O2            0.14%
CO            0.06%

• I'm guessing that the answer is "yes it would" but I'm not a chemist. – uhoh Jan 28 '20 at 13:39
• As soon as the mixture is allowed to reach equilibrium in the first place, yes. (I guess a billion years is quite enough.) Short of that, no. – Ivan Neretin Jan 28 '20 at 13:45
• Obviously not, because mars rotates and has a climate, with seasons. ;) – Karl Jan 28 '20 at 18:24
• @SurArthur7 thanks for the edit! I've never seen \pu{} used before but it looks great. I didn't find it in this tutorial so I'm wondering 1) what it's called, and 2) if it should be added there somewhere? – uhoh Jan 29 '20 at 0:14
• @Karl this question is not about Mars. That was included as "Background and motivation" but for this question in Chemistry SE I've stipulated a constant temperature and pressure for this gas mixture. – uhoh Jan 29 '20 at 0:24


text:
Search by Topic

Resources tagged with Mathematical reasoning & proof similar to Fixing It:

Filter by: Content type:
Stage:
Challenge level:

There are 184 results

Broad Topics > Using, Applying and Reasoning about Mathematics > Mathematical reasoning & proof

Stage: 4 Challenge Level:

A picture is made by joining five small quadrilaterals together to make a large quadrilateral. Is it possible to draw a similar picture if all the small quadrilaterals are cyclic?

Proof Sorter - Geometric Series

Stage: 5 Challenge Level:

This is an interactivity in which you have to sort into the correct order the steps in the proof of the formula for the sum of a geometric series.

Picture Story

Stage: 4 Challenge Level:

Can you see how this picture illustrates the formula for the sum of the first six cube numbers?

More Number Pyramids

Stage: 3 and 4 Challenge Level:

When number pyramids have a sequence on the bottom layer, some interesting patterns emerge...

Water Pistols

Stage: 5 Challenge Level:

With n people anywhere in a field each shoots a water pistol at the nearest person. In general who gets wet? What difference does it make if n is odd or even?

Three Balls

Stage: 4 Challenge Level:

A circle has centre O and angle POR = angle QOR. Construct tangents at P and Q meeting at T. Draw a circle with diameter OT. Do P and Q lie inside, or on, or outside this circle?

Plus or Minus

Stage: 5 Challenge Level:

Make and prove a conjecture about the value of the product of the Fibonacci numbers $F_{n+1}F_{n-1}$.

Stage: 4 and 5 Challenge Level:

This is an interactivity in which you have to sort the steps in the completion of the square into the correct order to prove the formula for the solutions of quadratic equations.

Long Short

Stage: 4 Challenge Level:

A quadrilateral inscribed in a unit circle has sides of lengths s1, s2, s3 and s4 where s1 ≤ s2 ≤ s3 ≤ s4. Find a quadrilateral of this type for which s1= sqrt2 and show s1 cannot. . . .

Direct Logic

Stage: 5 Challenge Level:

Can you work through these direct proofs, using our interactive proof sorters?

Rotating Triangle

Stage: 3 and 4 Challenge Level:

What happens to the perimeter of triangle ABC as the two smaller circles change size and roll around inside the bigger circle?

The Triangle Game

Stage: 3 and 4 Challenge Level:

Can you discover whether this is a fair game?

Particularly General

Stage: 5 Challenge Level:

By proving these particular identities, prove the existence of general cases.

Continued Fractions II

Stage: 5

In this article we show that every whole number can be written as a continued fraction of the form k/(1+k/(1+k/...)).

Yih or Luk Tsut K'i or Three Men's Morris

Stage: 3, 4 and 5 Challenge Level:

Some puzzles requiring no knowledge of knot theory, just a careful inspection of the patterns. A glimpse of the classification of knots and a little about prime knots, crossing numbers and. . . .

Modulus Arithmetic and a Solution to Dirisibly Yours

Stage: 5

Peter Zimmerman from Mill Hill County High School in Barnet, London gives a neat proof that: 5^(2n+1) + 11^(2n+1) + 17^(2n+1) is divisible by 33 for every non negative integer n.

More Sums of Squares

Stage: 5

Tom writes about expressing numbers as the sums of three squares.

Transitivity

Stage: 5

Suppose A always beats B and B always beats C, then would you expect A to beat C? Not always! What seems obvious is not always true. Results always need to be proved in mathematics.

Magic Squares II

Stage: 4 and 5

An article which gives an account of some properties of magic squares.

Recent Developments on S.P. Numbers

Stage: 5

Take a number, add its digits then multiply the digits together, then multiply these two results. If you get the same number it is an SP number.

Modulus Arithmetic and a Solution to Differences

Stage: 5

Peter Zimmerman, a Year 13 student at Mill Hill County High School in Barnet, London wrote this account of modulus arithmetic.

Sums of Squares and Sums of Cubes

Stage: 5

An account of methods for finding whether or not a number can be written as the sum of two or more squares or as the sum orf two or more cubes.

Picturing Pythagorean Triples

Stage: 4 and 5

This article discusses how every Pythagorean triple (a, b, c) can be illustrated by a square and an L shape within another square. You are invited to find some triples for yourself.

Try to Win

Stage: 5

Solve this famous unsolved problem and win a prize. Take a positive integer N. If even, divide by 2; if odd, multiply by 3 and add 1. Iterate. Prove that the sequence always goes to 4,2,1,4,2,1...

Whole Number Dynamics V

Stage: 4 and 5

The final of five articles which containe the proof of why the sequence introduced in article IV either reaches the fixed point 0 or the sequence enters a repeating cycle of four values.

Postage

Stage: 4 Challenge Level:

The country Sixtania prints postage stamps with only three values 6 lucres, 10 lucres and 15 lucres (where the currency is in lucres).Which values cannot be made up with combinations of these postage. . . .

Modular Fractions

Stage: 5 Challenge Level:

We only need 7 numbers for modulus (or clock) arithmetic mod 7 including working with fractions. Explore how to divide numbers and write fractions in modulus arithemtic.

Angle Trisection

Stage: 4 Challenge Level:

It is impossible to trisect an angle using only ruler and compasses but it can be done using a carpenter's square.

Little and Large

Stage: 5 Challenge Level:

A point moves around inside a rectangle. What are the least and the greatest values of the sum of the squares of the distances from the vertices?

Magic W Wrap Up

Stage: 5 Challenge Level:

Prove that you cannot form a Magic W with a total of 12 or less or with a with a total of 18 or more.

Stage: 5 Challenge Level:

Find all positive integers a and b for which the two equations: x^2-ax+b = 0 and x^2-bx+a = 0 both have positive integer solutions.

Stage: 5 Challenge Level:

As a quadrilateral Q is deformed (keeping the edge lengths constnt) the diagonals and the angle X between them change. Prove that the area of Q is proportional to tanX.

Always Perfect

Stage: 4 Challenge Level:

Show that if you add 1 to the product of four consecutive numbers the answer is ALWAYS a perfect square.

Mechanical Integration

Stage: 5 Challenge Level:

To find the integral of a polynomial, evaluate it at some special points and add multiples of these values.

Pythagorean Triples I

Stage: 3 and 4

The first of two articles on Pythagorean Triples which asks how many right angled triangles can you find with the lengths of each side exactly a whole number measurement. Try it!

Proof of Pick's Theorem

Stage: 5 Challenge Level:

Follow the hints and prove Pick's Theorem.

A Knight's Journey

Stage: 4 and 5

This article looks at knight's moves on a chess board and introduces you to the idea of vectors and vector addition.

Whole Number Dynamics IV

Stage: 4 and 5

Start with any whole number N, write N as a multiple of 10 plus a remainder R and produce a new whole number N'. Repeat. What happens?

Telescoping Functions

Stage: 5

Take a complicated fraction with the product of five quartics top and bottom and reduce this to a whole number. This is a numerical example involving some clever algebra.

Whole Number Dynamics III

Stage: 4 and 5

In this third of five articles we prove that whatever whole number we start with for the Happy Number sequence we will always end up with some set of numbers being repeated over and over again.

Whole Number Dynamics II

Stage: 4 and 5

This article extends the discussions in "Whole number dynamics I". Continuing the proof that, for all starting points, the Happy Number sequence goes into a loop or homes in on a fixed point.

Pythagorean Triples II

Stage: 3 and 4

This is the second article on right-angled triangles whose edge lengths are whole numbers.

Whole Number Dynamics I

Stage: 4 and 5

The first of five articles concentrating on whole number dynamics, ideas of general dynamical systems are introduced and seen in concrete cases.

Where Do We Get Our Feet Wet?

Stage: 5

Professor Korner has generously supported school mathematics for more than 30 years and has been a good friend to NRICH since it started.

Proofs with Pictures

Stage: 5

Some diagrammatic 'proofs' of algebraic identities and inequalities.

Breaking the Equation ' Empirical Argument = Proof '

Stage: 2, 3, 4 and 5

This article stems from research on the teaching of proof and offers guidance on how to move learners from focussing on experimental arguments to mathematical arguments and deductive reasoning.

The Clue Is in the Question

Stage: 5 Challenge Level:

This problem is a sequence of linked mini-challenges leading up to the proof of a difficult final challenge, encouraging you to think mathematically. Starting with one of the mini-challenges, how. . . .

Areas and Ratios

Stage: 4 Challenge Level:

What is the area of the quadrilateral APOQ? Working on the building blocks will give you some insights that may help you to work it out.


text:
Welcome guest
You're not logged in.
282 users online, thereof 0 logged in

Definition: Bernoulli Experiment

A Bernoulli experiment has the following properties:

• The experiment is repeated $$n$$ times.
• In each of the $$n$$ experiments, either the event $$A$$ occurs, or not (i.e. its complement $$\overline A$$ occurs).
• There is a constant probability $$p$$ for the event $$A_i$$ to have in the $$i$$-th experiment the outcome $$A$$, i.e. $$p(A_i)=p(A)=const$$ for all $$i$$
• The experiments $$A_1,\ldots, A_n$$ are mutually independent.

| | | | | created: 2016-03-18 22:13:45 | modified: 2016-03-18 22:29:19 | by: bookofproofs | references: [856]


text:
# 24.1. Introduction

The electric field of a given charge distribution can in principle be calculated using Coulomb's law. The examples discussed in Chapter 23 showed however, that the actual calculations can become quit complicated.

## 24.2. Gauss' Law

An alternative method to calculate the electric field of a given charge distribution relies on a theorem called Gauss' law. Gauss' law states that
" If the volume within an arbitrary closed mathematical surface holds a net electric charge Q, then the electric flux [Phi] though its surface is Q/[epsilon]0 "
Gauss' law can be written in the following form:

(24.1)
Figure 24.1. Electric flux through surface area A.
The electric flux [Phi] through a surface is defined as the product of the area A and the magnitude of the normal component of the electric field E:
(24.2) where [theta] is the angle between the electric field and the normal of the surface (see Figure 24.1). To apply Gauss' law one has to obtain the flux through a closed surface. This flux can be obtained by integrating eq.(24.2) over all the area of the surface. The convention used to define the flux as positive or negative is that the angle [theta] is measured with respect to the perpendicular erected on the outside of the closed surface: field lines leaving the volume make a positive contribution, and field lines entering the volume make a negative contribution.

### Example 1: Field of point charge.

The field generated by a point charge q is spherical symmetric, and its magnitude will depend only on the distance r from the point charge. The direction of the field is along the direction (see Figure 24.2). Consider a spherical surface centered around the point charge q (see Figure 24.2). The direction of the electric field at any point on its surface is perpendicular to the surface and its magnitude is constant. This implies that the electric flux [Phi] through this surface is given by

(24.3)
Figure 24.2. Electric field generated by point charge q.
Using Gauss's law we obtain the following expression
(24.4) or

(24.5) which is Coulomb's law.

### Example 2: Problem 24.16

Charge is uniformly distributed over the volume of a large slab of plastic of thickness d. The charge density is [rho] C/m3. The mid-plane of the slab is the y-z plane (see Figure 24.3). What is the electric filed at a distance x from the mid-plane ?
Figure 24.3. Problem 24.16.
As a result of the symmetry of the slab, the direction of the electric field will be along the x-axis (at every point). To calculate the electric field at any given point, we need to consider two separate case: - d/2 < x < d/2 and x > d/2 or x < -d/2. Consider surface 1 shown in Figure 24.3. The flux through this surface is equal to the flux through the planes at x = x1 and x = - x1. Symmetry arguments show that

(24.6) The flux [Phi]1 through surface 1 is therefore given by

(24.7) The amount of charge enclosed by surface 1 is given by

(24.8) Applying Gauss' law to eq.(24.7) and eq.(24.8) we obtain

(24.9) or

(24.10) Note: this formula is only correct for - d/2 < x1 < d/2.
The flux [Phi]2 through surface 2 is given by

(24.11) The charge enclosed by surface 2 is given by

(24.12) This equation shows that the enclosed charge does not depend on x2. Applying Gauss's law one obtains

(24.13) or

(24.14)

## 24.3. Conductors in Electric Fields

A large number of electrons in a conductor are free to move. The so called free electrons are the cause of the different behavior of conductors and insulators in an external electric filed. The free electrons in a conductor will move under the influence of the external electric field (in a direction opposite to the direction of the electric field). The movement of the free electrons will produce an excess of electrons (negative charge) on one side of the conductor, leaving a deficit of electrons (positive charge) on the other side. This charge distribution will also produce an electric field and the actual electric field inside the conductor can be found by superposition of the external electric field and the induced electric field, produced by the induced charge distribution. When static equilibrium is reached, the net electric field inside the conductor is exactly zero. This implies that the charge density inside the conductor is zero. If the electric field inside the conductor would not be exactly zero the free electrons would continue to move and the charge distribution would not be in static equilibrium. The electric field on the surface of the conductor is perpendicular to its surface. If this would not be the case, the free electrons would move along the surface, and the charge distribution would not be in equilibrium. The redistribution of the free electrons in the conductor under the influence of an external electric field, and the cancellation of the external electric field inside the conductor is being used to shield sensitive instruments from external electric fields.
The strength of the electric field on the surface of a conductor can be found by applying Gauss' law (see Figure 24.4). The electric flux through the surface shown in Figure 24.4 is given by

(24.15) where A is the area of the top of the surface shown in Figure 24.4. The flux through the bottom of the surface shown in Figure 24.4 is zero since the electric field inside a conductor is equal to zero. Note that eq.(24.15) is only valid close to the conductor where the electric field is perpendicular to the surface. The charge enclosed by the surface shown in Figure 24.4 is equal to
Figure 24.4. Electric field of conductor.

(24.16) where [sigma] is the surface charge density of the conductor. Eq.(24.16) is correct if the charge density [sigma] does not vary significantly over the area A (this condition can always be met by reducing the size of the surface being considered). Applying Gauss' law we obtain

(24.17) Thus, the electric filed at the surface of the conductor is given by

(24.18)


text:
Very high coverage Nanopore alignment Hg38
1
0
Entering edit mode
19 days ago
pablo ▴ 230

Hi,

I aligned my first Nanopore reads on the hg38 reference. Then, I used bedtools genomecov to get an idea about the mean coverage over the genome.

I noticed some bases have a very high coverage >20,000X , whereas the mean coverage is ~10X . I extracted the corresponding alignments (20,000X) from the bam file, and used IGV to have a look.

As you can see, the very-high covered region has many insertions (>100bp). We are not in a telomeric region. Why all the reads has this profile, and why so many reads mapped here ? I also checked the flags of the alignments here :

  number  flag
2532   2064
2488   2048
7367   272
7479   256
936   16
1023   0

There are many not primary alignments / secondary / supplementary alignments. But also, 1023 + 936 primary alignments, which gives a very high coverage anyway.

We have the same profile here, but in a telomeric region, with many repetitive motifs.

IGV nanopore alignment • 323 views
0
Entering edit mode

It seems that this is telomeric region of the chromosome and all the reads of clipped reads (I think its hard-clipped). I have also observed the same in my nanopore data. These are mapping artifacts in repeatative regions of the genome. You either need to identify these kind of regions in the BAM file and remove them prior to variant calling. Or, you can easily identify these regions from the resulting VCF file as well. In a VCF file, you need to look at the site mean depth (either using vcftools or bcftools) and then filter those sites having unusual depth of coverage.

Check out the way to do it from here: https://speciationgenomics.github.io/filtering_vcfs/ (check out these two sections: Calculate mean depth per site section and Variant mean depth)

Additionally, most variant callers only consider primary alignments, so you are also safe by not removing them as most of the reads are secondary. But there are other regions in the genome that may such artifacts, so its better to filter them off.

0
Entering edit mode
10 days ago

This will likely be an artifact, as you know. Check the Mapping quality MQ of these reads and use a MQ filter of 30 for example to avoid repeat regions.

This is also why people use MQ and maxDepth in their SNP calling. That said, I've never seen a region as bad as that.


text:
## Engage NY Eureka Math 8th Grade Module 2 Lesson 10 Answer Key

### Eureka Math Grade 8 Module 2 Lesson 10 Example Answer Key

Example 1.
The world population is about 7 billion. There are 4.6× 107 ants for every human on the planet. About how many ants are there in the world?
First, write 7 billion in scientific notation: (7× 109).
To find the number of ants in the world, we need to multiply the world population by the known number of ants for each person: (7× 109)(4.6× 107 ).
(7× 109)(4.6× 107 )=(7×4.6)( 109× 107) By repeated use of the associative and commutative properties
=32.2× 1016 By the first law of exponents
=3.22×10× 1016
=3.22× 1017 By the first law of exponents
There are about 3.22× 1017 ants in the world!

Example 2.
A certain social media company processes about 990 billion likes per year. If the company has approximately 8.9× 108 users of the social media, about how many likes is each user responsible for per year? Write your answer in scientific and standard notation.
First, write 990 billion in scientific notation: 9.9× 1011.
To find the number of likes per person, divide the total number of likes by the total number of users: $$\frac{9.9 \times 10^{11}}{8.9 \times 10^{8}}$$
$$\frac{9.9 \times 10^{11}}{8.9 \times 10^{8}}$$ = $$\frac{9.9}{8.9}$$×$$\frac{10^{11}}{10^{8}}$$ By the product formula
=1.11235…× 103 By the first law of exponents
≈1.1× 103
≈1100
Each user is responsible for about 1.1× 103, or 1,100, likes per year.

Example 3.
In 2010, Americans generated 2.5× 108 tons of garbage. There are about 2,000 landfills in the United States. Assuming that each landfill is the same size and that trash is divided equally among them, determine how many tons of garbage were sent to each landfill in 2010.
First, write 2,000 in scientific notation: 2× 103.
To find the number of tons of garbage sent to each landfill, divide the total weight of the garbage by the number of landfills: $$\frac{2.5 \times 10^{8}}{2 \times 10^{3}}$$.
$$\frac{2.5 \times 10^{8}}{2 \times 10^{3}}$$ = $$\frac{2.5}{2}$$× $$\frac{10^{8}}{10^{3}}$$ By the product formula
=1.25× 105 By the first law of exponents
Each landfill received 1.25× 105 tons of garbage in 2010.
Actually, not all garbage went to landfills. Some of it was recycled and composted. The amount of recycled and composted material accounted for about 85 million tons of the 2.5× 108 tons of garbage. Given this new information, how much garbage was actually sent to each landfill?
First, write 85 million in scientific notation: 8.5× 107.
Next, subtract the amount of recycled and composted material from the garbage: 2.5× 108-8.5× 107. To subtract, we must give each number the same order of magnitude and then use the distributive property.
2.5× 108-8.5× 107=(2.5×10)× 107-8.5× 107 By the first law of exponents
=(2.5×10)-8.5))× 107 By the distributive property
=(25-8.5)× 107
=16.5× 107
=1.65×10× 107
=1.65× 108 By the first law of exponents
Now, divide the new amount of garbage by the number of landfills: $$\frac{1.65 \times 10^{8}}{2 \times 10^{3}}$$.
$$\frac{1.65 \times 10^{8}}{2 \times 10^{3}}$$ = $$\frac{1.65}{2}$$× $$\frac{10^{8}}{10^{3}}$$ By the product formula
=0.825× 105 By the first law of exponents
=0.825×10× 104 By the first law of exponents
=8.25× 104
Each landfill actually received 8.25× 104 tons of garbage in 2010.

### Eureka Math Grade 8 Module 2 Lesson 10 Exercise Answer Key

Exercise 1.
The speed of light is 300,000,000 meters per second. The sun is approximately 1.5× 1011 meters from Earth. How many seconds does it take for sunlight to reach Earth?
300 000 000=3× 108
$$\frac{1.5 \times 10^{11}}{3 \times 10^{8}}$$ = $$\frac{1.5}{3}$$×$$\frac{10^{11}}{10^{8}}$$
=0.5× 103
=0.5×10× 102
=5× 102
It takes 500 seconds for sunlight to reach Earth.

Exercise 2.
The mass of the moon is about 7.3× 1022 kg. It would take approximately 26,000,000 moons to equal the mass of the sun. Determine the mass of the sun.
26 000 000=2.6× 107
(2.6× 107 )(7.3× 1022)=(2.6×7.3)( 107× 1022)
=18.98× 1029
=1.898×10× 1029
=1.898× 1030
The mass of the sun is 1.898× 1030 kg.

Exercise 3.
The mass of Earth is 5.9× 1024 kg. The mass of Pluto is 13,000,000,000,000,000,000,000 kg. Compared to Pluto, how much greater is Earth’s mass than Pluto’s mass?
13 000 000 000 000 000 000 000=1.3× 1022
5.9× 1024-1.3× 1022=(5.9× 102 )× 1022-1.3× 1022
=(590-1.3)× 1022
=588.7× 1022
=5.887× 102× 1022
=5.887× 1024
The mass of Earth is 5.887× 1024 kg greater than the mass of Pluto.

Exercise 4.
Using the information in Exercises 2 and 3, find the combined mass of the moon, Earth, and Pluto.
7.3× 1022+1.3× 1022+5.9× 1024=(7.3× 1022+1.3× 1022)+5.9× 1024
=8.6× 1022+5.9× 1024
=(8.6+590)× 1022
=598.6× 1022
=5.986× 102× 1022
=5.986× 1024
The combined mass of the moon, Earth, and Pluto is 5.986× 1024 kg.

Exercise 5.
How many combined moon, Earth, and Pluto masses (i.e., the answer to Exercise 4) are needed to equal the mass of the sun (i.e., the answer to Exercise 2)?
$$\frac{1.898 \times 10^{30}}{5.986 \times 10^{24}}$$=$$\frac{1.898}{5.986}$$ × $$\frac{10^{30}}{10^{24}}$$
≈0.32× 106
=0.32×10× 105
=3.2× 105
It would take 3.2× 105 combined masses of the moon, Earth, and Pluto to equal the mass of the sun.

### Eureka Math Grade 8 Module 2 Lesson 10 Problem Set Answer Key

Have students practice operations with numbers written in scientific notation and standard notation.

Question 1.
The sun produces 3.8× 1027 joules of energy per second. How much energy is produced in a year? (Note: a year is approximately 31,000,000 seconds).
31 000 000=3.1× 107
(3.8× 1027 )(3.1× 107 )=(3.8×3.1)( 1027× 107 )
=11.78× 1034
=1.178×10× 1034
=1.178× 1035
The sun produces 1.178× 1035 joules of energy in a year.

Question 2.
On average, Mercury is about 57,000,000 km from the sun, whereas Neptune is about 4.5× 109 km from the sun. What is the difference between Mercury’s and Neptune’s distances from the sun?
57 000 000=5.7× 107
4.5× 109-5.7× 107=(4.5× 102 )× 107-5.7× 107
=450× 107-5.7× 107
=(450-5.7)× 107
=444.3× 107
=4.443× 102× 107
=4.443× 109
The difference in the distance of Mercury and Neptune from the sun is 4.443× 109 km.

Question 3.
The mass of Earth is approximately 5.9× 1024 kg, and the mass of Venus is approximately 4.9× 1024 kg.
a. Find their combined mass.
5.9× 1024+4.9× 1024=(5.9+4.9)× 1024
=10.8× 1024
=1.08×10× 1024
=1.08× 1025
The combined mass of Earth and Venus is 1.08× 1025 kg.

b. Given that the mass of the sun is approximately 1.9× 1030 kg, how many Venuses and Earths would it take to equal the mass of the sun?
$$\frac{1.9 \times 10^{30}}{1.08 \times 10^{25}}$$ = $$\frac{1.9}{1.08}$$ × $$\frac{10^{30}}{10^{25}}$$
=1.75925…× 105
≈1.8× 105
It would take approximately 1.8× 105 Venuses and Earths to equal the mass of the sun.

### Eureka Math Grade 8 Module 2 Lesson 10 Exit Ticket Answer Key

Question 1.
The speed of light is 3× 108 meters per second. The sun is approximately 230,000,000,000 meters from Mars. How many seconds does it take for sunlight to reach Mars?
230 000 000 000=2.3× 1011
$$\frac{2.3 \times 10^{11}}{3 \times 10^{8}}$$ =$$\frac{2.3}{3}$$×$$\frac{10^{11}}{10^{8}}$$
=0.7666″…”× 103
≈0.77×10× 102
≈7.7× 102
It takes approximately 770 seconds for sunlight to reach Mars.

Question 2.
If the sun is approximately 1.5× 1011 meters from Earth, what is the approximate distance from Earth to Mars?


text:
A Deep CCD Survey for Cool Degenerate Stars: A New Photometric Technique
Session 47 -- Degenerates
Display presentation, Wednesday, 9:20-6:30, Pauley Room

## [47.07] A Deep CCD Survey for Cool Degenerate Stars: A New Photometric Technique

C. F. Claver (U. Texas Austin), J. Liebert (U. Arizona)

White dwarf stars are tracers of the age and evolution of the local Galactic disk through the white dwarf luminosity function (LF). The abrupt drop-off in the white dwarf luminosity function at $\log(L/L\sun) \approx -4.5$ has been used to derive the age of the galactic disk and to infer the age of the universe. However, uncertainties in the current LF prevent us from reaping the vast amount of information it contains; we must define it better. To this end we have recently commissioned a 46-arcminute field prime focus CCD imaging camera (PFC) on the McDonald 0.8-m reflector. We have begun a deep, large-area multi-color survey to discover cool white dwarf stars thus better define the cool end of the white dwarf luminosity function.

We have developed a new photometric technique that allows us to separate cool degenerate stars from other field stars having similar surface temperature, minimizing the need for individual spectroscopic followup. Initial selection of white dwarf candidates from $UBVRI$ photometry is followed by a refinement of the selection based on the strengths of the MgH and CaH bands, observed through $\sim400\AA~$ wide filters. These data remove most of the confusion in the colors of metal poor subdwarfs and bonafide degenerate white dwarfs in the K and M spectral range. We present photometry of a representative sample of 60 cool white dwarfs and metal poor subdwarfs demonstrating our technique.

If a separate population of white dwarfs exists in the galactic halo we can use their LF to determine if the halo age differs significantly from the age of the Galactic disk. Because of the limited volume searched by the proper motion surveys at low luminosities, the region in the WDLF fainter M$_{\rm v} \sim 18$ remains unexplored, hence we know very little about the the LF for halo white dwarfs. With the technique presented here we not only expect to find many disk white dwarfs but we will also be sensitive to white dwarfs which might be present in the halo.