A deep learning approach to handwritten text
recognition in the presence of struck-out text
Hiqmat Nisa, James A. Thom, Vic Ciesielski, Ruwan Tennakoon
School of Science, RMIT University, Melbourne-3000, Australia
hiqmat.nisa@student.rmit.edu.au, {james.thom, vic.ciesielski, ruwan.tennakoon}@rmit.edu.au
Abstract—The accuracy of handwritten text recognition may
be affected by the presence of struck-out text in the hand-
written manuscript. This paper investigates and improves the
performance of a widely used handwritten text recognition
approach Convolutional Recurrent Neural Network (CRNN) on
handwritten lines containing struck out words. For this purpose,
some common types of struck-out strokes were superimposed on
words in a text line. A model, trained on the IAM line database
was tested on lines containing struck-out words. The Character
Error Rate (CER) increased from 0.09 to 0.11. This model
was re-trained on dataset containing struck-out text. The model
performed well in terms of struck-out text detection. We found
that after providing an adequate number of training examples,
the model can deal with learning struck-out patterns in a way
that does not affect the overall recognition accuracy.
Index Terms—Handwritten Text Recognition, Struck-out text,
Deep Learning
I. I NTRODUCTION
Transcription of offline handwritten text is an essential area
of digital document analysis. For the last few decades, re-
searchers have been working on ways to improve the recogni-
tion accuracy of handwritten documents. Initially, recognition
of isolated characters was considered. However, the nature of
English handwriting does not consist of isolated characters
only, so the attention shifted from isolated characters to word
recognition. Although word recognition is challenging because
of the cursive nature and wide variability of different persons’
handwriting, good performance has been achieved using deep
learning neural networks [1], [2].
One constraint in most published work on handwritten text
recognition is that researchers consider only clean versions
of handwritten documents, i.e., documents free from writing
errors. However, a free-form of a handwritten document may
not be an ideal. It may have some corrections, deletions or
insertions while working on a second pass. For instance, writ-
ers strike-out inappropriate words and write appropriate words
next to or above the crossed-out. Some common examples of
crossed-out words are shown in Figure 1.
If these crossed-out words are input into a handwritten text
recognizer, arbitrary characters are produced as output. To
prevent the recognizer from producing incorrect output, re-
searchers have worked on a pre-processing module to prevent
978-1-7281-4187-9/19/$31.0©2019 IEEE
(a) Single line stroke
(b) Double line stroke
(c) Single diagonal stroke
(d) Crossed diagonal strokes
Fig. 1: Different types of struck-out strokes from the Modified-
IAM training set
struck-out text from entering into the recognizer [3], [4]. In
that case, a handwritten document is divided into small chunks
(can be a word or words) and recognized as regular text or
struck-out text. After removing the struck-out text, the regular
text is sent to the recognizer.
The purpose of this paper is to investigate the performance
of the widely used handwritten text recognition approach,
that is Convolutional Recurrent Neural Network (CRNN) on
handwritten lines containing struck out words. This network
consists of three different components: CNN (Convolutional
Neural Network), LSTM (Long Short Term Memory) and
CTC (Connectionist temporal classification) [5]. In this work,
we generated a synthetic database containing crossed-out text
from a well-known line version of the English language
database IAM [6]. We generated some common types of
struck-out strokes, depicted in Figure 1: a horizontal straight
line through the middle of the word, two strokes crossing the
text, a single diagonal stroke and two diagonal strokes crossing
each other in the middle of the word. We train the CRNN on
the IAM database and on the synthetically created database
and report the results.
Our research questions are:
1 What will be the effect of struck-out text on a handwritten
text recognition system based on CRNN?
2 How can the training procedure of a CRNN network be
modified to correctly identify struck-out text in a handwritten
line without affecting the accuracy of the text recognition?
The remainder of the paper is organized as follows: Section
II presents related work on struck-out text identification, the
methodology used in this paper is explained in Section III and
experimental results and conclusion are presented in Sections
IV and V, respectively.
II. R ELATED W ORK
Several papers have been published on struck-out text
processing in recent years. Likforman-Sulem and Vinciarelli
[7] assessed the robustness of a HMM based classifier in
the presence of struck-out text, by inducing struck-out words.
For this purpose, the HMM was trained on clean handwritten
words and tested on synthetic data that included struck-out
words with wave trajectories and line-trajectories. They found
a moderate decrease in performance for single writer data. For
multiple writers, the performance was worse. In their study,
the authors did not train the model on strike-outs and did not
attempt to detect the strike-outs.
Adak et al. [3] investigated the impact of the struck-out text
on the writer identification task. Their approach was a hybrid
approach of CNN and SVM to detect words as struck-out or
not before recognition. The authors concluded that struck-out
text degrades the performance of writer identification. This
work is not directly related to our work as its main task is
related to writer identification rather than text recognition.
However, it includes of the struck-out text identification part.
Another study by Brink et al. [8] automatically identified and
removed crossed-out text using two simple features, branching
and size. A simple decision tree was used for the classification
of crossed-out and normal text.
Studies performed by Chaudhuri and Adak [4] [9] tried
to identify and remove struck-out strokes from handwritten
documents. In these studies, a SVM based classifier was used
for struck-out word detection. [4] is limited to straight lines
only. In [9], different types of stroke were considered, e.g.,
straight and zigzag for two languages English and Bengali. In
the above study the length of connected components is used
to detect and distinguish a word, successive multi-words, or
multi-line struck-out.
All of the above work handles struck-out text as a binary
classification problem i.e. considers the text as struck-out or
normal. However, there can be situations when punctuation
written at the end of a word is crossed-out. Apart from that,
handwriting recognition approaches shifted from character to
word then line and paragraph recognition, yet none of the
above consider recognition on line-level or paragraph-level in
the presence of struck-out text. In this paper we work on a
line-level to identify struck-out text which includes words and
punctuation.
III. M ETHODOLOGY
A. Generating Synthetic Database
This section describes the generation of the synthetic
database required for training and performance analysis. The
publicly available English handwritten texts database IAM [6]
(a) Ground Truth: the # Ministry of Labour. This scheme is
designed
(b) Ground Truth: # winter. In late November, he was ‘suffering
as
(c) Ground Truth: down # unambiguous alternatives to
Fig. 2: Examples of struck-out text from IAM database
is widely used for handwritten recognition tasks. We used the
image sets appearing in the “Large Writer Independent Text
Line Recognition Task” as the basis of synthetic database.
There are 9,862 text lines divided into 6161 lines for training,
900 lines for validation1, 940 lines for validation2, and 1861
lines for testing. There are 79 different symbols, including
lowercase and capital letters, digits, punctuation marks and
the symbol # for struck-out words.
This database contains only 55 struck-out words which are
labeled with the symbol #, an example of such words can be
seen in Figure 2. All these 55 words appear in training set or
validation set. None of the words in the test data are labeled
with #. We also found a few unlabeled struck-out words in
this database. The small number of struck-out words present
in the IAM database are not sufficient for training the model.
Therefore, we synthetically crossed out random words from
the subset of IAM database using several types of strokes.
First, the bounding box of each word in a line was detected
using the line segmentation method described by Manmatha
and Srimal [10]. The bounding box covers the core area of
the word. Then at random, a word is crossed-out within the
core area. From the IAM training and validation sets, 30%,
and 25% of samples were used to generate struck-out texts,
respectively. The annotation of these struck-out words was
replaced with the symbol #. The modified version of IAM
database which we call Modified-IAM contains a total of 1900
text lines of training and 280 of validation. Each line contains
a random struck-out word at a different position, 480 lines out
of 1861 from the IAM test set were selected randomly and we
superimposed a stroke/s on a random word within a line. So
our Modified-IAM test set contains 1381 original lines and
480 lines having a crossed-out word. The detail of the data
sets is shown in a Table I.
We considered the following parameters for strike-out stroke
generation.
i. Cross-out stroke style: widely used cross-out strokes were
considered, namely, single line stroke (Figure:1a), double-line
stroke (Figure:1b), single diagonal stroke (Figure:1c), and two
diagonal strokes crossing each other (Figure:1d). All these
strokes are drawn using straight lines.
ii. Cross-out stroke value: Our model is trained on greyscale
images. So it is important to match the value of the stroke
 Fig. 3: Network Architecture used in this paper based on [5].
with the written text on the image. For this purpose, the value
of a cross-out stroke is calculated from the histogram of the
greyscale image. A frequency-based histogram was generated
on a selected range of values of a greyscale image. A value
with the highest frequency was selected for the cross-out
stroke.
iii. Cross-out stroke width: Cross-out strokes are usually
made by the instruments that are used for writing. The tip
of the same instrument determines the width of the writing
strokes. To produce more realistic strokes, it is essential to
match the stroke width with the written text width. To find the
average width of writing strokes in handwritten text line we
find all the strokes in terms of connected components in a text
line, then we apply the Euclidean distance transform [11] to
every connected component. The distance transform calculates
a distance from each stroke point to the nearest boundary point
on the stroke. So, we find all the points that share maximum
distance from stroke to boundary. These points represent the
middle of the stroke. We take the average of all these distances,
which determines the half-width of the stroke. For full stroke
width, we multiply that number by two.
TABLE I: Data Sets
IAM Modified-IAM
#Lines in Training 6161 1900
#Lines in Validation 900 280
#Lines in Test 1861 1861
#Struck-out words in Training 50 1900
#Struck-out words in Test 0 480
#Non-struck-out words in Training 53757 14040
#Non-struck-out words in Test 17560 17080
B. Network Architecture
Prior deep learning network architectures used for handwrit-
ing recognition consist of a combination of Multi-Dimensional
LSTM layers and convolutional layers [2]. The use of Multi-
Dimensional LSTM layers in the early stages has some
drawbacks. It requires more memory for the activations, back-
propagation and the runtime needed to train a network is also
higher [12]. The network architecture presented by Shi et al.
[5] has been used in this work and is shown in Figure :3.
The network uses convolutional layers as feature extractors.
This avoids the use of Multi-Dimensional LSTM layers. A
1D bidirectional-LSTM is used to perform the classification.
Recently, it has been established by Joan Puigcerver [1] that
convolutional layers used for feature extraction learn similar
features as Multi-Dimensional LSTM layers.
1) Convolutional Layers: The neural network consists of
five convolutional blocks. Each convolutional block contains
a two-dimensional convolutional layer with a kernel size of
3x3 pixels with a stride of 1x1. The number of filters at the
five different layers are 16, 32, 48, 65, and 80, respectively. To
reduce overfitting, dropout regularization is applied at the rate
of 0.2 at the output of every convolutional layer except the first.
Leaky Rectifier Linear Units (LeakyReLU) have been used as
the activation functions in the convolutional blocks. Finally,
after each of the first three convolutional layers, the output
of the activation function is fed to a max-pooling layer with
kernels of 2x2 pixels. The max-pooling layer is commonly
used to reduce the dimensionality of the input images. To
convert 3D tensors of size (width x height x depth) into a
2D shape of size (width x (height x depth)), a column-wise
concatenation is performed after the 5th convolutional layer.
So the number of features to passed the bidirectional-LSTMs
is equal to the 80 x Height, Height is the height of the image
after three stages of max-pooling.
2) Recurrent Layers: Recurrent blocks contain bidirec-
tional 1D-LSTM layers that scan the image columnwise i.e.
in left-to-right and right-to-left orders. After the CNN stage,
five bidirectional 1D-LSTM recurrent layers having 256 units
in each direction are used. A depth-wise concatenation is
performed on the output of the two 1D-LSTM layers. A
dropout with 0.5 probability is also applied to LSTM layers.
3) Fully connected layer: Finally, a fully connected layer
with L+1 nodes is used on the output of the 5th bidirectional
LSTM layer. The term L refers to the number of characters
in IAM dataset, which is 79, and one additional dimension
is required for the blank symbol of CTC [13]. Overall, this
CRNN architecture has a 9,581,008 learnable parameters.
IV. E XPERIMENTS AND RESULTS
In this section, we present the experimental setup, results
and the struck-out texts recognition accuracy, and an analysis
of their effect on handwritten text recognition.

(a) Training of Model-1
(b) Training of Model-2
(c) Training of Model-3
Fig. 4: Training of three different Models
A. Training a model on IAM database (Model-1)
We trained the CRNN architecture (as implemented1 by
Jaramilo et al. [12]) from scratch on the IAM database to
get the state-of-art recognition accuracy. We did not apply
any pre-processing except resizing all the images of same
height and width as CRNN accepts all the images of same
size. No language model was used during training. The CRNN
was trained using the Adam optimizer, and the parameters
1 The code URL: https://github.com/josarajar/HTRTF
were updated using a gradient of CTC loss on the batch of
20 text lines. We set the hyper-parameter learning rate to
0.003. The performance of the handwritten text recognition is
measured as Character Error Rate (CER) and Word Error Rate
(WER). CER and WER are calculated using the Levenstein
edit distance [14]. This distance computes the number of edit
operations performed to transform one string into another
string. We achieved 0.02 and 0.08 CER on training and
validation, respectively. The training and validation progress
can be seen in Figure 4a.
After getting the trained model, we tested this model on
the IAM test set and achieved 0.09 CER. After that, we test
this model on the Modified-IAM test set to check the struck-
out text recognition accuracy of this model. We observe an
increase in CER from 0.09 to 0.11 and WER from 0.24 to
0.25. To investigate this performance degradation, we analyze
the output of the struck-out text predicted by the model. The
model tries to predict the struck-out characters from the trained
character set, as shown in Figure 5. The performance of struck-
out detection is calculated as.
True Positive (TP) = number of actual struck-out words
correctly detected.
False Negative (FN) = number of actual struck-out words
incorrectly recognized as normal words
False Positive (FP) = number of normal words incorrectly
recognized as struck-out
True Negative (TN) = number of normal words correctly
detected as normal
On the Modified-IAM test set, we observed 25 TP out of
480 struck-out words. The remaining 455 words were not
predicted as struck-out (see Table II). However, they were
predicted as a sequence of letters from the training character
set. There were no FP.
(a) Ground Truth: they will # give us their hypnotic
Predicted: they vili pochably give us their hypnotic
(b) Ground Truth: # how the Thetan machinations had been
Predicted: Higg how the Thetan machinations had been
Fig. 5: Some examples Modified-IAM tested on Model-1
TABLE II: Confusion matrix on Modified-IAM Test set for
Model-1
Actual
Struck-out Not struck-out
Struck-out 25 0
Not Struck-out 455 17080
B. Training from scratch on Struck-out database (Model-2)
From the above results, we observe that the struck-out words
appearing in the IAM training dataset were not sufficient to
learn the pattern of struck-out texts. So, we used the Modified-
IAM database and trained the model from scratch. The same
CRNN architecture and training parameters were used to train
Model-2 on the synthetic database. 1900, 280, and 1861 lines
of text were used for training, validation, and testing purposes,
respectively.
During training, we were regularly checking the graph for
loss and accuracy. We stopped training after 160 epochs as the
training CER reached 0.05, but on the validation set CER was
0.20 (shown in Figure 4b). On the other hand, the loss on the
validation data set started to increase after 150 epochs, which
shows overfitting. The overfitting was likely due to the small
number of training samples.
We test the model on the Modified-IAM test set. The test set
was fed to the trained model, and we observe a CER of 0.26
and WER of 0.49. The reason for this higher CER and WER is
the small number of training examples used to train the model.
We also analyze the output of the Modified-IAM test data,
despite a low text recognition rate, we observe that Model-2
correctly identified 435 out of 480 struck-out words as symbol
#. So, the Model-2 performed well on struck-out recognition
but did not learn different varieties of handwritten text. It
is necessary to provide more training examples to overcome
the overfitting, and a model will learn more variability in
handwriting. This conclusion encourages us to retrain Model-
1 on a Modified-IAM database, which was already trained on
the IAM database.
TABLE III: CER and WER for the three models
IAM Modified-IAM
test set test set
start of
training data CER WER CER WER
training
Model-1 scratch IAM 0.09 0.23 0.11 0.25
Model-2 scratch Modified-IAM 0.26 0.50 0.26 0.49
Model-3 Model-1 Modified-IAM 0.11 0.27 0.11 0.27
C. Training with transfer learning (Model-3)
We have seen that Model-1 performance decreases on the
Modified-IAM test set, and Model-2 is overfitted. In this
experiment, we re-train Model-1 on the Modified-IAM training
dataset so that our final model learns the struck-out text pattern
along with the variabilities in handwriting.
We have already achieved the state-of-art CER and WER on
Model-1. To train the Model-3, we initialize the whole network
with the learned weights of Model-1. We did not freeze any
layer, as suggested by Jaramillo et al. [12] because with few
training examples, the best strategy is to re-train the whole
network. Our transfer strategy was simple. We keep all the
learned values of the trained Model-1 because the Modified-
IAM database is created from IAM and has the same number
of labels, which is 79. The same architecture and training
parameters were used to re-train the model. We achieved 0.01
and 0.09 CER on the training and validation sets after only 50
epochs. Usually, fewer epochs are required in transfer learning
as models are initialized with learned values. The training of
Model-3 is shown Figure 4c.
After getting the trained model, the Modified-IAM test set
was fed to the model to assess the performance of the model
on struck-out text detection and recognition accuracy. We
achieved 0.11 CER and 0.27 WER. We also achieved similar
CER and WER on the IAM test set. A comparison of these
three models on the two different test sets is shown in Table
III.
TABLE IV: Confusion matrix on Modified-IAM Test set for
Model-3
Actual
Struck-out Not struck-out
Struck-out 439 144
Not Struck-out 41 16936
(a) Ground Truth: # came to just over six hundred
Predicted: # came # just over six hundred
(b) Ground Truth: to # other day, my lord. A being of whom
Predicted: to # other day, my lord. # being of whom
(c) Ground Truth: the Avenue from its many tributary streets.
It might have
Predicted: the Avenue from #s many tirlumary #r.It might have
Fig. 6: Some Examples of False-Positive on Model-3
(a) ’,’ not detected as struck-out
(b) Crossed-out ’I’ detected as ’t’
(c) ’the’ not detected as struck-out
Fig. 7: Some examples of False-Negative on Model-3
D. Discussion
Table III shows the CER and WER of the three different
models tested on IAM and Modified-IAM test sets. The CER
of Model-1 increases from 0.09 to 0.11 after introducing
struck-out text in the test data. The possible explanation for
this higher CER could be that the model tries to predict the
characters of struck-out text. We also observe an interesting
finding about struck-out text detection. Although Model-1 was
trained on only a small number of originally struck-out words,
it correctly identified 25 struck-out words. All these 25 words
contained crossed-out strokes generated by us. After analysing
all the correctly identified struck-outs, it is found that most
of the text have two strokes (diagonal or straight). None of
the correctly identified struck-outs contains a single struck-
out stroke. This is because most of the originally struck-out
examples in IAM have more than one stroke.
Our purpose was to detect struck-out texts without affecting
the recognition accuracy on normal text. From all the above
experiments, after providing adequate training examples of
struck-out text, our Model-3 correctly identified almost 439
out of 480 struck-out words along with a 0.11 CER. We
also observe a small number of false negativities and quite
a few false positives. In both cases, only short words or
punctuations are detected incorrectly. Mostly false positives
consist of a letter ‘t’ and capital ‘A’. This may be because both
characters contain a straight line (see Figure 6). Regarding
false negatives, coma (,), colon (:), and question-mark (?) were
incorrectly identified. Such type of symbols are usually found
at the end of the non-struck words, making them hard to detect
(Figure 7a). Apart from that, FN also contains letters which
change its shape from one character to another, e.g. ‘I’ to
‘t’, after being struck-out (Figure 7c). In some cases, where a
stroke looks like a part of the word (Figure 7b).
V. C ONCLUSION
The principal contributions of this paper are investigating:
(1) the effect of struck-out text on a handwritten text recog-
nition system based on CRNN (2) how the training procedure
of a CRNN can be modified to correctly identify struck-out
text in a handwritten line without affecting the accuracy of the
text recognition. To address these questions, we synthetically
superimpose struck-out stroke/s on a subset of a well known
the English database IAM, which we call Modified-IAM.
For question (1), we trained a model on the IAM dataset
and tested it on both the IAM and the Modified-IAM test
sets. Our experiment showed that testing a model on lines
containing struck-outs decreased the recognition accuracy. We
observed an increase in character error rate from 0.09 to 0.11
and word error rate from 0.23 to 0.25 on the IAM and the
Modified-IAM test sets, respectively.
For question (2), we re-trained the previous model with
Modified-IAM which contains 1900 samples of struck-out
words. We tested this model on both the IAM and Modified-
IAM test sets. We observed the same 0.11 character error rate
and 0.27 word error rate on both sets. It also performed well
in terms of struck-out detection, 439 out of 480 struck-out
words were detected correctly. We conclude that our model
successfully detected struck-out words without affecting the
accuracy of overall text recognition. It can be concluded that,
in this case 1900 training samples are enough for the CRNN
model to learn the four basic types of stuck-out strokes.
In some situations, our model detected normal text as
struck-out (false positives) on both test sets which negatively
effected the recognition accuracy. These false positives usually
occurred in two situations, (1) a straight line is a part of
the letter as in ‘t’ or ‘A’, and (2) on punctuation marks
especially comma (,), colon (:), and question mark (?). Some
improvement is required to prevent a network from producing
such false positives.
We have shown that it is possible to modify CRNN training
to accommodate some form of struck-out text without loss of
accuracy. In future work we will investigate a wider range
of struck-out forms. For example, stuck-out stroke/s do not
always start from the left of a word and end at the right side.
Also there are some situations where only part of a word is
crossed-out.
ACKNOWLEDGMENT
This work was partially funded by the government of
Pakistan under the project “HDR INITIATIVE-MS LEADING
TO PhD PROGRAM OF FACULTY DEVELOPMENT FOR
UESTPS/UETS, PHASA-1”, and by the RMIT University
Australia.
R EFERENCES
[1] J. Puigcerver, “Are multidimensional recurrent layers really necessary
for handwritten text recognition?” in 2017 14th IAPR International
Conference on Document Analysis and Recognition (ICDAR), vol. 1.
IEEE, 2017, pp. 67–72.
[2] P. Voigtlaender, P. Doetsch, and H. Ney, “Handwriting recognition
with large multidimensional long short-term memory recurrent neural
networks,” in 2016 15th International Conference on Frontiers in
Handwriting Recognition (ICFHR). IEEE, 2016, pp. 228–233.
[3] C. Adak, B. B. Chaudhuri, and M. Blumenstein, “Impact of struck-out
text on writer identification,” in 2017 International Joint Conference on
Neural Networks (IJCNN). IEEE, 2017, pp. 1465–1471.
[4] C. Adak and B. B. Chaudhuri, “An approach of strike-through text
identification from handwritten documents,” in 2014 14th International
Conference on Frontiers in Handwriting Recognition. IEEE, 2014, pp.
643–648.
[5] B. Shi, X. Bai, and C. Yao, “An end-to-end trainable neural network
for image-based sequence recognition and its application to scene
text recognition,” IEEE transactions on pattern analysis and machine
intelligence, vol. 39, no. 11, pp. 2298–2304, 2016.
[6] U.-V. Marti and H. Bunke, “The iam-database: an english sentence
database for offline handwriting recognition,” International Journal on
Document Analysis and Recognition, vol. 5, no. 1, pp. 39–46, 2002.
[7] L. Likforman-Sulem and A. Vinciarelli, “Hmm-based offline recognition
of handwritten words crossed out with different kinds of strokes,” 2008.
[8] A. Brink, H. van der Klauw, and L. Schomaker, “Automatic removal
of crossed-out handwritten text and the effect on writer verification and
identification,” in Document Recognition and Retrieval XV, vol. 6815.
International Society for Optics and Photonics, 2008, p. 68150A.
[9] B. B. Chaudhuri and C. Adak, “An approach for detecting and cleaning
of struck-out handwritten text,” Pattern Recognition, vol. 61, pp. 282–
294, 2017.
[10] R. Manmatha and N. Srimal, “Scale space technique for word segmen-
tation in handwritten documents,” in International conference on scale-
space theories in computer vision. Springer, 1999, pp. 22–33.
[11] J. C. Elizondo-Leal and G. Ramirez-Torres, “An exact euclidean distance
transform for universal path planning,” in 2010 IEEE Electronics,
Robotics and Automotive Mechanics Conference. IEEE, 2010, pp. 62–
67.
[12] J. C. Aradillas, J. J. Murillo-Fuentes, and P. M. Olmos, “Boosting
handwriting text recognition in small databases with transfer learning,”
arXiv preprint arXiv:1804.01527, 2018.
[13] A. Graves, S. Fernández, F. Gomez, and J. Schmidhuber, “Connection-
ist temporal classification: labelling unsegmented sequence data with
recurrent neural networks,” in Proceedings of the 23rd international
conference on Machine learning. ACM, 2006, pp. 369–376.
[14] V. I. Levenshtein, “Binary codes capable of correcting deletions, inser-
tions, and reversals,” in Soviet physics doklady, vol. 10, no. 8, 1966, pp.
707–710.