# Challenges and Opportunities in the Co-design of Convolutions and RISC-V
Vector Processors

Sonia Rani Gupta  Chalmers University of TechnologyGothenburgSweden
<EMAIL_ADDRESS>,  Nikela Papadopoulou  Chalmers University of
TechnologyGothenburgSweden<EMAIL_ADDRESS>and  Miquel Pericàs  Chalmers
University of TechnologyGothenburgSweden<EMAIL_ADDRESS>
(2023)

###### Abstract.

The RISC-V ”V” extension introduces vector processing to the RISC-V
architecture. Unlike most SIMD extensions, it supports long vectors which can
result in significant improvement of multiple applications. In this paper, we
present our ongoing research to implement and optimize a vectorized Winograd
algorithm used in convolutional layers on RISC-V Vector(RISC-VV) processors.
Our study identifies effective techniques for optimizing the kernels of
Winograd on RISC-VV using intrinsic instructions, and showcases how certain
instructions offer better performance. Our co-design findings suggest that the
Winograd algorithm benefits from vector lengths up to 2048 bits and cache
sizes up to 64MB.

We use our experience with Winograd to highlight potential enhancements for
the standard that would simplify code generation and aid low-level
programming. Finally, we share our experience from experimenting with forks of
gem5 for RISC-VV and stress the importance of a mature software ecosystem, to
facilitate design space exploration and architectural optimization.

Our study identifies effective techniques for optimizing the kernels of
Winograd on RISC-VV using the available intrinsic instructions and showcases
that certain instructions offer better performance to the vectorized
algorithm. Furthermore, our co-design study reveals that the Winograd
algorithm benefits from vector lengths up to 2048 bits and cache sizes up to
64MB.

Performance, Winograd, Optimization, RISC-V Vector extension, ARM-SVE

††journalyear: 2023††copyright: rightsretained††conference: Workshops of The
International Conference on High Performance Computing, Network, Storage, and
Analysis; November 12–17, 2023; Denver, CO, USA††booktitle: Workshops of The
International Conference on High Performance Computing, Network, Storage, and
Analysis (SC-W 2023), November 12–17, 2023, Denver, CO, USA††doi:
10.1145/3624062.3624232††isbn: 979-8-4007-0785-8/23/11††ccs: Computing
methodologies Vector / streaming algorithms††ccs: Computer systems
organization Single instruction, multiple data

##  1\. Introduction

RISC-V, an open standard Instruction Set Architecture (ISA), has gained
significant interest in the High-Performance Computing (HPC) and Artificial
Intelligence (AI) communities as an alternative to proprietary architectures,
such as x86, ARM, and CUDA. One of the main advantages of RISC-V is its
customizable nature, allowing for bespoke designs to meet specific HPC/AI
needs. The ”V” extension of RISC-V adds vector processing, allowing
implementations to process large amounts of data in a parallel and efficient
manner.

Vector architectures have evolved considerably since they were first
introduced in early systems such as the Cray-1 (Russell, 1978). Modern vector
extensions can broadly be classified into two groups. In the first group,
fixed-length vector extensions are common for media processing such as audio
or video processing. This includes vector extensions such as Intel x86 MMX,
SSE, AVX, AVX2, and AVX512 (Intel, 2020), and ARM NEON (ARM, 2013), in which
vector registers are of fixed length. On the other hand, ARM SVE (Stephens,
2017) and RISC-V Vector Extension (RISC-VV) (”RISCV”, [n. d.]) are extensions
to the respective ISAs based on long vectors and vector length agnostic ISAs,
and can result in significant performance improvements for a wide range of
applications, including scientific computing, machine learning, and multimedia
processing. One of the key features of ARM-SVE and RISC-VV is their support
for long vector lengths, which enables high parallelism with lower complexity
for the architecture. This feature also improves the energy efficiency by
reducing the number of instructions required to complete a task, thereby
reducing the energy consumed by the processor’s front end, which is a
significant concern for servers with power caps and mobile devices with
limited battery life. Another key feature is the vector length agnostic (VLA)
nature of these ISAs, which provides code portability across implementations
with different hardware vector lengths. Vector processors based on VLA are
featured in various designs such as EPI’s Vector accelerator (Initiative,
2019), Fujitsu A64FX (Fujitsu, 2021) and ARM Neoverse-V1 (Arm, 2021).

The RISC-V Vector extension has been implemented with vector lengths up to
16384 bits (Cavalcante et al., 2019; Minervini et al., 2023). The supported
vector length is an important feature to improve the efficiency of heavily
compute-intensive applications, or applications with regular, high data-level
parallelism (Ramírez et al., 2020). Several works (Gómez et al., 2023, 2021)
focus on porting and optimizing HPC kernels and applications on long-vector
architectures. In our previous work (Gupta et al., 2023), we have focused on
convolutional neural networks (CNNs) on long vector architectures. We have
ported and optimized the im2col+GEMM and Winograd algorithms, found in the
compute-intensive convolutional layers, concluding that longer vector lengths
(up to 8192 bits) are beneficial to the performance of CNNs.

In this work, we extend our previous work(Gupta et al., 2023) with an
optimized implementation of the Winograd (Alam et al., 2022; Coppersmith and
Winograd, 1990) algorithm using RISC-VV, and use our optimized implementations
of the convolutional layers, with both im2col+GEMM, and Winograd, for a co-
design study on a simulated RISC-V processor featuring the ”V” extension. We
focus on the RISC-V Vector Extension v1.0, and use the intrinsics available in
the RISC-V LLVM/Clang toolchain (Ferrer, 2022) from the European Processor
Initiative (EPI) (Initiative, 2019), to vectorize the kernels in Winograd.

In summary, this paper makes the following contributions:

  * •

We present our experience in vectorizing and optimizing the Winograd kernels
using RISC-VV in a vector length agnostic way. We showcase effective
techniques to vectorize the Winograd kernels, leveraging the available
intrinsic instructions. We demonstrate that workarounds to avoid indexed
vector load/stores can offer significant performance

  * •

We perform a co-design study for the VGG16 network model, using our vectorized
and optimized Winograd algorithm for the convolutional layers. Considering the
vector length and L2 cache size in our exploration, we show that Winograd is
able to utilize vector lengths up to 2048 bits, improving performance by
$\sim$1.4$\times$ compared to a vector length of 512 bits, however longer
vector lengths do not offer further gains. Additionally, Winograd scales up to
64MB of L2 cache size, but does not require larger cache sizes. Through a
similar co-design study for the YOLOv3 network model, which uses both
im2col+GEMM and Winograd to implement the convolutional layers, we show that
vector lengths of 4096 bits improve performnace by 1.76$\times$ and a L2 cache
size of 256MB improves performance further by 1.5$\times$ (i.e. 2.6$\times$ in
total), compared to a 512-bit long vector architecture with 1MB of L2 cache
size.

  * •

Finally, we use the Winograd algorithm as a case study to compare the RISC-VV
and ARM-SVE ISAs. We observe similar performance and performance trends, on
both RISC-VV and ARM-SVE architectures. We also discuss our experience with
simulators/emulators available for RISC-VV and highlight the necessity of
mature toolchains and alignment between the compilers and tools.

##  2\. Implementation of Convolutions

The convolutional layer can be implemented using different algorithmic
implementations such as Direct, im2col+GEMM, Winograd, and FFT. The Direct
convolution implementation is mainly used for 1x1 kernel size, as its memory
footprint increases with larger kernel sizes and it exhibits low data reuse,
although recent approaches have optimized the Direct convolution for SIMD
(Zhang et al., 2018) and long-vector architectures (Santana et al., 2023). The
Winograd implementation reduces the computational complexity but is mainly
helpful in 3$\times$3 or 5$\times$5 kernel sizes, because of a numerical
inaccuracy issue for large kernel sizes. FFT also has the advantage of
reducing the complexity but is beneficial with bigger kernel sizes. On the
other hand, im2col+GEMM can be generically applied and is efficient on most
modern architectures (Ben-Nun and Hoefler, 2019). The latest, state-of-the-art
convolutional network models mainly employ kernel sizes of 1$\times$1,
3$\times$3, or 5$\times$5, making Winograd and im2col+GEMM better choices for
implementing the convolutional layer.

In this work, we port and optimize the Winograd algorithm from the NNPACK
(Dukhan, 2016) software library, to implement convolutional layers with
3$\times$3 kernel size, of stride equal to 1. In our evaluation, for the
remaining convolutional layers, with different kernel sizes or strides, we use
the im2col+GEMM implementation from the Darknet framework (Redmon, 2016).

The Winograd algorithm involves transforming both the input data and filter
data, performing tuple multiplication on the resulting, transformed matrices,
and then transforming the output back to its original form. The Winograd
algorithm, as implemented in NNPACK, uses an 8$\times$8 input tile and a
3$\times$3 filter to produce a 6$\times$6 output. Vectorization with longer
vector lengths requires employing a scheme of inter-tile parallelization,
across the input/output channels by taking an 8$\times$8 tile from each
channel, as explained in our previous work (Gupta et al., 2023). In this work,
we use the same inter-tile parallelization scheme as a base for vectorizing
the Winograd algorithm in a VLA way, to utilize the longer vector lengths
available on the RISC-VV architecture.

The im2col+GEMM algorithm relies on the im2col kernel to transform the input
into column matrices, and on the common GEMM kernel to execute matrix
multiplication on the input matrix and the transformed column matrix. We are
vectorizing and optimizing im2col and GEMM kernels in a VLA way to utilize the
longer vector lengths efficiently as shown in (Gupta et al., 2023). We are
using our optimized implementation for these kernels for the convolutional
layers, where we can not use the Winograd implementation.

##  3\. Winograd Implementation on RISC-VV

As discussed in Section 2, we have used an inter-tile parallelism approach
across the input/output channels, to be able to vectorize the Winograd
algorithm for longer vector lengths. To utilize 512-bit vector registers, we
use 8$\times 8$ tiles from 4 channels. In order to fully utilize longer vector
lengths, e.g. 8192-bit vector lengths, we need to use equivalently more
channels, e.g. to use 64 channels. In the convolutional layers where the
number of channels is more than 4, we enable inter-tile parallelism for RISC-
VV. Further, to vectorize the tuple multiplication, which can employ up to
8192-bit-long vectors, we now increase the number of blocks to 64, with 4
elements in each block. Thus, we can vectorize and use the Winograd algorithm
with long vectors with RISC-VV. To manually vectorize all the kernels of the
Winograd algorithm, we use the intrinsics available in the EPI LLVM/Clang
toolchain for the RISC-V Vector Extension. We note that we also use the
compiler auto-vectorization capabilities to let all the kernels to auto-
vectorize. After examining the produced assembly code, we have observed that
only one loop out of all kernels is auto-vectorized. Therefore, for further
experimentation, we use manually vectorized kernels.

During the process of manually vectorizing with intrinsic instructions, as
well as in our evaluation (see Section 4), we demonstrate the use of effective
intrinsics (and RISC-VV instructions) for the vectorization of the Winograd
algorithm, which we have evaluated with small code snippets. Based on this
experience, we hint towards best-performing instructions, as well as towards
some enhancements in RISC-VV, which would boost low-level/assembly-level
programmability. In the next paragraphs, we highlight the most important parts
of our optimization process.

### Input transformation.

In the input transformation kernels of Winograd, approximately 30 instructions
which transform the input data and produce the transformed output are used at
6 places, with different input data sets. These instructions produce the
intermediate output before producing the final, transformed output. In this
scenario, it would be more practical to incorporate these instructions into a
function and invoke it whenever transformation is necessary. However, this
function must update output registers with the transformed output, thus
requiring that output registers be passed as a reference. As RISC-VV does not
support pointers with vector datatypes, while optimizing the input
transformations using manual vectorization on RISC-VV, we are forced to
incorporate these 30 instructions in the main function at 6 different places,
making the code lengthy, error-prone, and less efficient. The same holds for
the kernel and output transformation. Although using macros as an alternative
to functions can help improve the readability of the code, the extended need
for intermediate registers can still cause register spilling. Although the
compiler can optimize register usage through heuristics, the programmer may
not be able to avoid register spilling. As a result, we conclude that having
pointers with vector data types in the ”V” extension will improve the
programmability and will also help reduce the chances of register spilling.

Algorithm 1 Tuple multiplication code snippet from Winograd showcasing the
indexed load work-around in RISC-VV

1: $ind\leftarrow 0$

2: VL = get vector length

3: $elements=4$

4: $rem=VL/elements$

5: $num\leftarrow blocks*4$ //64 blocks

6: $iteration\leftarrow num/64$

7: for $i\leftarrow 0$, $i<rem$, $i+=1$ do

8: for $j\leftarrow 0$, $j<4$, $j+=1$ do

9: $index[ind]=j$

10: $ind++$;

11: end for

12: end for

13: for $itr\leftarrow 0$, $itr<num$ do

14: $gvl=setvl(num-itr)$

15: $index\\_vec\leftarrow index[0:gvl]$

16: for $k\leftarrow 0$, $k<iteration$, $k+=1$ do

17: for $j\leftarrow 0$, $j<inputchannels$, $j+=1$ do

18: $b0\\_vec\leftarrow B[itr+(j*VL)]$ //load filter matrix

19: for $i\leftarrow 0$, $i<64$, $i+=4$ do

20: $a0\\_vec\leftarrow indexed\\_load(A[(i+(64*k))+(j*VL)],index\\_vec,gvl])$

21: $acc\\_vec[i]\leftarrow vfmacc(acc\\_vec[i],a0\\_vec,b0\\_vec,gvl)$

22: end for

23: end for

24: //Store results in the resultant matrix in a contiguous way

25: end for

26: $itr+=gvl$;

27: end for

Algorithm 2 Tuple multiplication code snippet from Winograd using the slideup
instructions in RISC-VV

1: $ind\leftarrow 0$

2: VL = get vector length

3: $iteration\leftarrow num/64$

4: for $itr\leftarrow 0$, $itr<num$ do

5: $gvl=setvl(num-itr)$

6: $index\\_vec\leftarrow index[0:gvl]$

7: for $k\leftarrow 0$, $k<iteration$, $k+=1$ do

8: for $j\leftarrow 0$, $j<inputchannels$, $j+=1$ do

9: $b0\\_vec\leftarrow B[itr+(j*VL)]$ //load filter matrix

10: for $i\leftarrow 0$, $i<64$, $i+=4$ do

11: $a0\\_vec\leftarrow load(A[(i+(64*k))+(j*VL)],gvl])$

12: for $ind\leftarrow 0$, $4*ind<=gvl/2$, $ind+=1$ do

13: $a0\\_vec\leftarrow Slideup(a0\\_vec,4*ind,gvl)$

14: end for

15: $acc\\_vec[i]\leftarrow vfmacc(acc\\_vec[i],a0\\_vec,b0\\_vec,gvl)$

16: end for

17: end for

18: //Store results in the resultant matrix in a contiguous way

19: end for

20: itr+=gvl;

21: end for

Algorithm 3 Transpose code snippet from Winograd for RISC-VV

1: $VL$ = vector length

2: $gvl$ = granted vector length

3: $V0,V1,V2,V3$ //Vector registers

4: $vin0123[0]\leftarrow V0$

5: $vin0123[VL]\leftarrow V1$

6: $vin0123[2*VL]\leftarrow V2$

7: $vin0123[3*VL]\leftarrow V3$

8: $ind\leftarrow 0$

9: for $j=0$, $j<4$, $j+=1$ do

10: $index[ind]=((j*VL))$

11: $ind++$

12: end for

13: //load index in $index\\_vec$

14: $trans\\_vec[0:gvl]\leftarrow$
$indexed\\_load(\&vin0123[0],index\\_vec,gvl)$

Algorithm 4 Transpose code snippet using strided from Winograd for RISC-VV

1: $VL$ = vector length

2: $gvl$ = granted vector length

3: $V0,V1,V2,V3$ //Vector registers

4: $vin0123[0]\leftarrow strided\\_store(V0,stride,gvl)$

5: $vin0123[1]\leftarrow strided\\_store(V1,stride,gvl)$

6: $vin0123[2]\leftarrow strided\\_store(V2,stride,gvl)$

7: $vin0123[3]\leftarrow strided\\_store(V3,stride,gvl)$

8: $trans\\_vec[0:gvl]\leftarrow load(\&vin0123[0],gvl)$

### Tuple multiplication.

In the tuple multiplication kernel from the Winograd algorithm, the logic
requires reading a block of 4 $\times$ 32-bit elements (quadword) from the
transformed input matrix, to perform the element-wise multiplication with the
loaded transformed filter matrix. For this task, which is illustrated in
Figure 1, there is no matching intrinsic available, thus we have explored
different intrinsic instructions to fill in the vector register from the
quadword. In our first attempt, we have used the indexed vector load intrinsic
to fill the vector register, which we present in Algorithm 1. In line 18, we
employ an indexed vector load operation to retrieve a quadword from the $A$
matrix. To use the indexed vector load, we generate indices in lines 5 to 10
and load them into the index vector $index\\_vec$. We then utilize the index
vector as the second argument when loading data from the $A$ matrix to the
$a0\\_vec$ vector register. Our preliminary evaluation showed that these
indexed load/store (gather/scatter) instructions are expensive, therefore, we
have taken an alternative approach, using the slideup intrinsic instruction,
which we illustrate in Algorithm 2. In line 10, we use a vector load operation
to retrieve data from the $A$ matrix in the $a0\\_vec$ vector register. Then
we use the slideup intrinsic instructions from line 12 to line 14 to fill the
vector with the quadword data. We have compared tuple multiplication with the
two approaches, for a 100 iterations, finding that tuple multiplication using
the slideup intrinsic is $\sim$2.3$\times$ faster than using the indexed
load/store instructions (see Section 4 for the experimental setup).

Figure 1.  Indexed load for packing quadword in a 512-bit vector register

### Transpose operation.

For the transformations in the Winograd algorithm, we perform the transpose
operation on an array of 4 vectors, as shown in Figure 2. However, in RISC-VV,
currently, no specific instructions are available to perform these operations
(transposing the two vectors is available as EPI custom extensions (Ferrer,
2022), but not in the standard ”V” extension). We, therefore, implement a
solution that uses temporary buffers and additional store and gather-load
instructions as shown in Algorithm 3. To transpose 4 vectors, the process
involves storing the vector data into buffer $vin0123$ using memory operations
in lines 2 to 5. Subsequently, we generate indices and load them into the
$index\\_vec$ vector register in lines 8 to 12. Finally, we use an indexed
load vector instruction in line 13 to load the transposed values from the
buffer into a vector register.

As an alternative approach, we have also used strided stores to store the
intermediate vector results in the buffer $vin0123$, using a stride of 16 (4
single-precision floating-point elements) to transpose the vectors. We
demonstrate this approach in lines 4 to 7 of Algorithm 4. In this approach,
the already transposed data is loaded in line 8 using a contiguous load
intrinsic instruction. Comparing the performance of the two approaches for
transformations (see Section 4 for the experimental setup), we did not observe
any significant performance difference. We note, however, that both cases
require memory operations, i.e. scatter/store and gather/load instructions,
which put a burden on performance, as well as programmability, forcing the
developer to implement more complex solutions. Therefore, we advocate for an
extension of the RISC-VV with vector transpose instructions, that would
eliminate the need for memory operations.

Figure 2.  Transpose the elements of the vectors residing in vector registers
V0, V1, V2, and V3.

##  4\. Experimental Setup

For our work, we use the EPI-Builtins (Ferrer, 2022) to vectorize the kernels
of the Winograd algorithm from the NNPACK (Dukhan, 2016) package with VLA
vectorization on RISC-VV. We use the EPI fork of the LLVM (BSC, 2023) Clang
cross-compiler version 17.0.0 for RISC-VV with -O3 optimization flag to
compile the algorithm and the network models. To validate our algorithms
during development, we use Spike (riscv-software src, 2021), a RISC-V ISA
simulator that supports vector lengths up to 4096 bits and supports the ”V”
extension v1.0. To evaluate the performance of our optimized algorithm and
explore the impact of hardware parameters, such as the vector length and the
L2 cache size, on performance, we use a fork of the gem5 (plctlab, 2022)
simulator, a cycle-accurate simulator configured with the RISC-V in-order
RiscvMinorCPU CPU model, with a core frequency of 2GHz, for RISC-VV, targeting
the RISC-VV 1.0. The memory subsystem of RiscvMinorCPU is configured with two
levels of data cache, 64kB of L1 and 1MB of L2 cache. Note that this fork of
gem5 models a constant latency for all the vector instructions. In practice,
the latency of the instructions will vary with the implementation of RISCV-V.

We evaluate our optimized Winograd algorithm in the context of the
convolutional layers found in two network models, YOLOv3 (Redmon and Farhadi,
2018), an object detection network model, and VGG16, an image classification
network model, from the Darknet (Redmon, 2016) framework, on an inference task
with a 768$\times$576 pixels input image.

##  5\. Results

The convolutional layers of YOLOv3 use both $1\times 1$ and $3\times 3$ kernel
sizes, with stride 1 and higher, therefore we use our optimized Winograd
algorithm to implement the convolutional layers with kernel sizes $3\times 3$
and stride equal to 1, and use our optimized im2col+GEMM algorithm (Gupta et
al., 2023) for the remaining layers, in what we call the _hybrid approach_. We
then compare the performance achieved by the hybrid approach compared to the
pure im2col+GEMM approach, where all layers are implemented with im2col+GEMM.
To avoid extreme simulation times, and without loss of generality, we simulate
only the first 20 layers of the network model, out of which 15 are
convolutional layers. Compared to the pure im2col+GEMM approach, the hybrid
approach achieves an $\sim 8\%$performance improvement on a simulated RISC-V
processor with a vector length of 2048 bits and an L2 cache of 1MB, using
gem5. We conclude that the Winograd algorithm runs faster compared to
im2col+GEMM on RISC-V. The reason for the limited performance improvement is
that, out of the 20 layers, only 5 layers use the Winograd algorithm and
contribute to the performance improvement, as 3 layers have a stride equal to
2, 6 layers have a $1\times 1$ kernel size, the first layer uses only 3 input
channels, and 5 layers are not convolutional layers. Finally, for performance
validation, we compare the performance achieved on RISC-VV to the performance
we have previously achieved with ARM-SVE on gem5, with the same CPU model,
finding that Winograd performs the same on both vector architectures.

We then perform a co-design study to assess the impact on performance of
tuning the hardware parameters of RISC-VV using the gem5 simulator. The
available fork of the gem5 simulator for RISC-VV allows us to simulate only up
to 4096 bits long vector lengths. We simulate vector lengths of 512 bits up to
4096 bits, and L2 cache sizes of 1 up to 256 MB. We demonstrate our results in
Figure 3. We observe a speedup of $\sim$1.76$\times$ by increasing the vector
length from 512 bits to 4096 bits. Along with the indexed load, the L2 cache
miss rate is another factor that limits the scalability with longer vector
lengths. As shown in Table 1, increasing the vector length makes the L2 cache
miss rate increase, as longer vectors process more data at once and thus
require bigger caches to pump more data to the vector units for processing. By
increasing the cache size from 1MB to 256MB for different vector lengths, we
observe a speedup of 1.5$\times$ from 1MB to 256MB of L2 cache size for
512-bit and 1024-bit vector lengths, and 1.54$\times$ and 1.6$\times$ for
2048-bit and 4096-bit vector lengths respectively.

Table 1. L2 cache miss rate of YOLOv3 inference on RISC-VV for 1MB of L2 cache. Vector length | L2 cache miss rate(%)
---|---
512-bit | 39
1024-bit | 47
2048-bit | 50
4096-bit | 52

We additionally evaluate our implementation of Winograd with the VGG16 network
model, where all the layers are convolutional with a kernel of size $3\times
3$ and a stride of 1, we thus use Winograd for all the layers of the network
model. Comparing the performance of VGG16 using Winograd against VGG16 using
im2col+GEMM for all layers, on our simulated RISC-VV architecture with gem5,
we observe a speedup of $1.2\times$ for a vector length of 2048 bits and 1MB
of L2 cache. We then perform a similar exploration of hardware parameters as
for YOLOv3. We showcase the results in Figure 4. We observe that as we
increase the vector length from 512 bits to 4096 bits, the performance
improves by 1.4$\times$. However, we do not see a significant improvement
beyond 2048 bits. For further investigation, we examine the impact of the L2
cache miss rate for different vector lengths, which we present in Table 2. We
observe that the L2 cache miss rate is unaffected by the vector length and
does not limit performance scaling beyond 2048 bits. Additionally, from
analyzing the gem5 statistics, we observe that there is no significant
difference in the number of instructions from 2048-bit to 4096-bit vector
lengths, which indicates that our Winograd algorithm does not utilize very
long vector lengths. Due to reduced computational complexity, Winograd reduces
the required floating point operations for implementing the convolutional
layer and therefore can provide performance benefits with moderately large
vector lengths. Also, our roofline analysis (see Section 6 shows that the
Winograd algorithm is memory-bound on the simulated architecture, which limits
its scalability with longer vector lengths. To observe the impact of bigger
cache sizes, we increase the cache sizes from 1MB to 256MB for different
vector lengths and observe performance improvement of $\sim$1.3$\times$ from
1MB to 64MB for different vector lengths. Beyond 64MB of cache, no significant
performance improvement is observed. This concludes that our Winograd
implementation does not require very large L2 caches and can scale with
moderately large cache sizes. This observation is in accordance with our
conclusions from optimizing Winograd with ARM-SVE.

Table 2. L2 cache miss rate of VGG16 inference on RISC-VV for 1MB of L2 cache. Vector length | L2 cache miss rate(%)
---|---
512-bit | 80
1024-bit | 84
2048-bit | 85
4096-bit | 82
Figure 3.  Impact of vector lengths and L2 cache size with Winograd on RISC-
VV@gem5 for YOLOv3. Figure 4.  Impact of vector lengths and L2 cache size with
Winograd on RISC-VV@gem5 for VGG16.

##  6\. Roofline Analysis

We perform a roofline model (Williams et al., 2009) analysis for the
convolutional layers of VGG-16 using our Winograd implementation, for the
single core simulated by gem5 for RISC-VV with a 512-bit vector length and 1MB
of cache, with peak GFLOPS as 64 GFLOPS/sec and memory bandwidth as 13GB/sec.
We use the profiling data from gem5 to compute the arithmetic intensity (AI)
for each convolutional layer of VGG-16, i.e. each layer includes all the
transformation kernels along with the tuple multiplication kernel for all the
layers of the VGG-16 network model. We note that we calculate the arithmetic
intensity based on the DRAM bytes. For all the layers, we also validate our
calculated GFLOPS against theoretically calculated GFLOPS for Winograd. Figure
5 shows the roofline model of the first 10 convolutional layers of the VGG-16
network model on gem5 for RISC-VV. Our roofline analysis shows that all the
layers of VGG-16 are memory-bound, and this is the reason behind less
scalability with longer vector lengths and large caches. However, our roofline
analysis also shows that there is a scope for further improvement in the
kernels of the Winograd algorithm as the values of the plots are far away from
the memory bandwidth ceiling, therefore Winograd could benefit from cache-
aware optimizations.

Further, Figure 6 shows a similar roofline analysis of the first 10
convolutional layers of VGG-16, implemented with im2col+GEMM, on gem5 for
RISC-VV. This plot shows that only 3 layers out of 10 layers are memory-bound,
while the rest of the layers are compute-bound. This also supports our co-
design findings for YOLOv3, which scales better with longer vector lengths, as
it uses our hybrid approach, where some of the convolutional layers are using
im2col+GEMM. However, we note that, as in the case of Winograd, the achieved
performance is far from the peak performance ceiling, therefore there is room
for further optimization of this method on vector architectures.

Figure 5.  Roofline for the first 10 convolutional layers of VGG16 implemented
with Winograd on RISC-VV@gem5 Figure 6.  Roofline for the first 10
convolutional layers of VGG16 implemented with im2col+GEMM on RISC-VV@gem5

##  7\. Discussion on Tools

Multiple emulators/simulators such as Spike (riscv-software src, 2021), Vehave
(BSC, 2020), and gem5 (Ramírez, 2020) provide support for simulating the
vector instructions for RISC-VV. Spike is a functional simulator normally used
for validating the vectorized implementation and supports up to 4096-bit
vector length. Vehave is an emulator used for validating the correctness of
results and is useful for collecting execution traces. These traces can be
used with the MUSA simulator (BSC, [n. d.]) for RISC-VV for further
performance evaluation and exploration. Vehave supports up to 16384-bit vector
lengths for RISC-VV, however, it can be only used on RISC-V hosts. On the
other hand, gem5 is a cycle-accurate simulator that provides detailed
performance analysis and allows to tune micro-architectural parameters. Two
gem5 forks for RISC-VV exist, one implementing the ”V” extension v0.7
(Ramírez, 2020) and one implementing the ”V” extension v1.0 (plctlab, 2022).

In our work, we opt to use the gem5 simulator, as it allows us to study the
impact of several hardware parameters, such as vector lengths, cache sizes,
and the number of vector lanes on performance. Additionally, unlike the
Vehave/MUSA toolchain, which targets the RISC-V architecture, it does not
require a specific host, and also allows us to perform the same analysis on
different architectures (e.g. ARM-SVE). However, developing and maintaining
the tools plays a vital role in evaluating the performance of the architecture
and studying the crucial architecture parameters tuning for enhancing the
performance. While working with RISC-VV we encountered limitations; the gem5
simulator for RISC-VV (Ramírez, 2020), based on decoupled vector architecture,
is no longer maintained and therefore does not support the latest version of
the extension or latest compiler. The alternative fork of gem5 (plctlab, 2022)
for RISC-VV, used in this work, is based on an integrated vector architecture
and very long vector architecture support is not available yet. Also, there is
no coordination among tools for supported vector lengths. Such limitations
make progress slow, both in software and hardware design.

We believe that the software ecosystem plays a vital role in the maturation of
architectures and in assessing the porting efforts and the expected
performance of ported and optimized kernels, especially when the architecture
is not yet realized in real hardware. Moreover, the coordination of the
evolution of the ISA with the compiler and emulation/simulation tools is
important, to relieve the developer from the unnecessary burden of porting and
maintaining low-level code, and to increase programmability, allowing the
developer to benefit from the latest optimizations in compilers.

##  8\. Conclusion

In this paper, we presented our vectorized and optimized implementation of the
Winograd algorithm, used to implement convolutional layers, on RISC-V, using
the “V” vector extension (RISC-VV) through intrinsic instructions. Our
vectorization and optimization effort revealed that workarounds for contiguous
loads/stores alongside slideup instructions are more performant than
scatter/gather (indexed) loads/stores, and that strided vector instructions
perform equally to scatter/gather instructions in the task of transposing a
vector, as they both cannot avoid memory accesses. We evaluated our optimized
Winograd for RISC-VV on gem5 on an inference task using the YOLOv3 and VGG16
network models, achieving $1.08\times$ and $1.76x$ speedup respectively,
compared to using im2col+GEMM for the implementation of the convolutional
layers. We performed a co-design study for the two network models, considering
the vector length and L2 cache size as tunable hardware parameters. Our
results showed that Winograd’s algorithmic implementation does not require
very long vector lengths i.e. beyond 2048 bits, because Winograd reduces the
computational complexity and the total required floating point operations for
implementing the convolutional layer. Our analysis also showed that Winograd
does not have a very large L2 cache requirement, and can scale effectively
with up to 64MB of L2 cache.

From our experience with optimizing for RISC-VV, we emphasize the significance
of ensuring coordination in the progress between tools, ISAs, and compilers,
in order to facilitate porting and optimization, as well as design space
exploration for future architectures. Without such coordination, it can prove
challenging to navigate the software and hardware design space.

###### Acknowledgements.

This work has been supported by the Swedish Research Council via registration
number 2020-04892. The simulations were enabled by resources provided by the
National Academic Infrastructure for Supercomputing in Sweden (NAISS) at PDC
partially funded by the Swedish Research Council through grant agreement no.
2022-06725.

## References

  * (1)
  * Alam et al. (2022) Syed Asad Alam, Andrew Anderson, Barbara Barabasz, and David Gregg. 2022.  Winograd Convolution for Deep Neural Networks: Efficient Point Selection.  _ACM Trans. Embed. Comput. Syst._ (mar 2022).  https://doi.org/10.1145/3524069 Just Accepted.
  * ARM (2013) ARM. 2013.  _ARM Neon Programmer’s Guide_.  https://documentation-service.arm.com/static/5f731b591b758617cd95559c?token=
  * Arm (2021) Arm. 2021.  _Arm Neoverse V1 Platform:A revolution in high performance computing_.
  * Ben-Nun and Hoefler (2019) Tal Ben-Nun and Torsten Hoefler. 2019.  Demystifying Parallel and Distributed Deep Learning: An In-Depth Concurrency Analysis.  _ACM Comput. Surv._ 52, 4, Article 65 (aug 2019), 43 pages.  https://doi.org/10.1145/3320060
  * BSC ([n. d.]) BSC. [n. d.].  _MUSA-RISCV processor model and its architecture parameters_.  https://ssh.hca.bsc.es/epi/ftp/doc/MUSA_model_v4.pdf
  * BSC (2020) BSC. 2020.  _vehave-user-guide_.
  * BSC (2023) BSC. 2023.  _LLVM EPI Compiler_.  https://ssh.hca.bsc.es/epi/ftp/
  * Cavalcante et al. (2019) Matheus Cavalcante, Fabian Schuiki, Florian Zaruba, Michael Schaffner, and Luca Benini. 2019\.  Ara: A 1-GHz+ scalable and energy-efficient RISC-V vector processor with multiprecision floating-point support in 22-nm FD-SOI.  _IEEE Transactions on Very Large Scale Integration (VLSI) Systems_ 28, 2 (2019), 530–543.
  * Coppersmith and Winograd (1990) Don Coppersmith and Shmuel Winograd. 1990.  Matrix multiplication via arithmetic progressions.  _Journal of Symbolic Computation_ 9, 3 (1990), 251–280.  https://www.sciencedirect.com/science/article/pii/S0747717108800132 Computational algebraic complexity editorial.
  * Dukhan (2016) Marat Dukhan. 2016\.  _NNPACK_.
  * Ferrer (2022) Roger Ferrer. 2022\.  _epi-builtins-ref_.  https://repo.hca.bsc.es/gitlab/rferrer/epi-builtins-ref
  * Fujitsu (2021) Fujitsu. 2021.  _SuperComputer Fugaku_.  https://www.fujitsu.com/global/about/innovation/fugaku/
  * Gómez et al. (2021) Constantino Gómez, Filippo Mantovani, Erich Focht, and Marc Casas. 2021.  Efficiently running SpMV on long vector architectures. In _Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming_. 292–303.
  * Gómez et al. (2023) Constantino Gómez, Filippo Mantovani, Erich Focht, and Marc Casas. 2023.  HPCG on long-vector architectures: Evaluation and optimization on NEC SX-Aurora and RISC-V.  _Future Generation Computer Systems_ (2023).
  * Gupta et al. (2023) Sonia Rani Gupta, Nikela Papadopoulou, and Miquel Pericas. 2023\.  Accelerating CNN inference on long vector architectures via co-design. In _2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS)_. IEEE, 145–155.
  * Initiative (2019) European Processor Initiative. 2019\.  V for vector: software exploration of the vector extension of RISC-V.  https://www.european-processor-initiative.eu/v-for-vector-software-exploration-of-the-vector-extension-of-risc-v/.
  * Intel (2020) Intel. 2020.  _Instruction Set Extensions and Future Features Programming Reference_.  https://software.intel.com/content/www/us/en/develop/download/intel-architecture-instruction-set-extensions-programming-reference.html
  * Minervini et al. (2023) Francesco Minervini, Oscar Palomar, Osman Unsal, Enrico Reggiani, Josue Quiroga, Joan Marimon, Carlos Rojas, Roger Figueras, Abraham Ruiz, Alberto Gonzalez, et al. 2023\.  Vitruvius+: An Area-Efficient RISC-V Decoupled Vector Coprocessor for High Performance Computing Applications.  _ACM Transactions on Architecture and Code Optimization_ 20, 2 (2023), 1–25.
  * plctlab (2022) plctlab. 2022.  _plct-gem5_.
  * Ramírez (2020) Cristóbal Ramírez. 2020\.  A RISC-V Simulator and Benchmark Suite for Designing and Evaluating Vector Architectures.  _ACM Trans. Archit. Code Optim._ 17, 4, Article 38 (Nov. 2020), 30 pages.  https://doi.org/10.1145/3422667
  * Ramírez et al. (2020) Cristóbal Ramírez, César Alejandro Hernández, Oscar Palomar, Osman Unsal, Marco Antonio Ramírez, and Adrián Cristal. 2020\.  A risc-v simulator and benchmark suite for designing and evaluating vector architectures.  _ACM Transactions on Architecture and Code Optimization (TACO)_ 17, 4 (2020), 1–30.
  * Redmon (2016) Joseph Redmon. 2013–2016.  Darknet: Open Source Neural Networks in C.  http://pjreddie.com/darknet/.
  * Redmon and Farhadi (2018) Joseph Redmon and Ali Farhadi. 2018.  YOLOv3: An Incremental Improvement.  _arXiv_ (2018).
  * ”RISCV” ([n. d.]) ”RISCV”. [n. d.].  _RISC-V Vector_.  https://github.com/riscv/riscv-v-spec/releases
  * riscv-software src (2021) riscv-software src. 2021\.  _Spike RISC-V ISA Simulator_.
  * Russell (1978) Richard M. Russell. 1978\.  The CRAY-1 Computer System.  _Commun. ACM_ 21, 1 (Jan. 1978), 63–72.  https://doi.org/10.1145/359327.359336
  * Santana et al. (2023) Alexandre de Limas Santana, Adrià Armejach, and Marc Casas. 2023\.  Efficient Direct Convolution Using Long SIMD Instructions. In _Proceedings of the 28th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming_. 342–353.
  * Stephens (2017) N. Stephens. 2017\.  The ARM Scalable Vector Extension.  _IEEE Micro_ 37, 2 (2017), 26–39.  https://doi.org/10.1109/MM.2017.35
  * Williams et al. (2009) Samuel Williams, Andrew Waterman, and David Patterson. 2009\.  Roofline: an insightful visual performance model for multicore architectures.  _Commun. ACM_ 52, 4 (2009), 65–76.
  * Zhang et al. (2018) Jiyuan Zhang, Franz Franchetti, and Tze Meng Low. 2018\.  High performance zero-memory overhead direct convolutions. In _International Conference on Machine Learning_. PMLR, 5776–5785.


# On the smoothability problem with rational coefficients

Olivier Benoist  Département de mathématiques et applications, École normale
supérieure et CNRS, 45 rue d’Ulm, 75230 Paris Cedex 05, France
<EMAIL_ADDRESS>and  Claire Voisin  Institut de Mathématiques de
Jussieu-Paris rive gauche et CNRS, 4 Place Jussieu, 75252 Paris Cedex 05,
France<EMAIL_ADDRESS>
###### Abstract.

We consider the problem of smoothing algebraic cycles with rational
coefficients on smooth projective complex varieties up to homological
equivalence. We show that a solution to this problem would be incompatible
with the validity of the Hartshorne conjecture on complete intersections in
projective space. We also solve unconditionally a symplectic variant of this
problem.

## Introduction

###  0.1. Smoothing cycles

Let $X$ be a smooth projective variety of dimension $n$ over ${\mathbb{C}}$.
For $c\geq 0$, consider the subgroup $H^{2c}(X,{\mathbb{Z}})_{\mathrm{alg}}$
of $H^{2c}(X,{\mathbb{Z}})$ generated by fundamental classes of (closed
irreducible algebraic) subvarieties of codimension $c$ in $X$. Borel and
Haefliger have asked in [BH61, Section 5.17] whether
$H^{2c}(X,{\mathbb{Z}})_{\mathrm{alg}}$ is generated by classes of smooth
subvarieties. In other words, is it possible to smooth algebraic cycles up to
homological equivalence?

The strongest result in that direction, due to Kollár and Voisin [KV23,
Theorem 1.2] (following an earlier work of Hironaka [Hir68, Theorem, Section
5, p. 50]), states that the answer to this question is positive in the range
$c>\frac{n}{2}$. Additional positive results have been obtained by Kleiman
[Kle69, Theorem 5.8] when $c=2$ and $n\in\\{4,5\\}$.

It was however discovered by Hartshorne, Rees and Thomas [HRT74, Theorem 1]
that the answer to the question of Borel and Haefliger is negative in general.
Further counterexamples have appeared in [Deb95, Théorème 6], in [Ben20,
Theorem 0.3] (which includes examples in the threshold case $c=\frac{n}{2}$),
and in [BD23, Theorem 1.2].

###  0.2. Rational coefficients

We shall focus on the rational analogue of this question.

######  Question 0.1.

Let $X$ be a smooth projective variety over ${\mathbb{C}}$. Fix $c\geq 0$. Is
the ${\mathbb{Q}}$-vector space $H^{2c}(X,{\mathbb{Q}})_{\mathrm{alg}}$
generated by classes of smooth subvarieties of codimension $c$ in $X$?

The above question was investigated by Kleiman in [Kle69] by exploiting the
formula ${c_{c}(\mathcal{O}_{Z})=(-1)^{c}(c-1)!\,[Z]}$, a well-known
consequence of the Grothendieck–Riemann–Roch theorem valid for all codimension
$c$ subvarieties $Z\subset X$. Using this formula, one can reduce Question 0.1
to the case of Chern classes of vector bundles, which come by pull-back from
Grassmannians (see the discussion in [Kle69, p. 282]). On the one hand, this
reduces Question 0.1 to the case where $X$ is a Grassmannian. On the other
hand, combined with an analysis of the singularities of the Schubert
subvarieties of Grassmannians, this line of reasoning allowed Kleiman to show
that Question 0.1 has a positive answer when $c>\frac{n}{2}-1$ (see [Kle69,
Theorem 5.8]).

In constrast with the integral case, no counterexample to Question 0.1 has
been discovered to date. It is not even known whether the original
counterexample of Hartshorne, Rees and Thomas to the integral question – the
second Chern class of the tautological bundle on the Grassmannian $G(3,6)$ –
is a ${\mathbb{Q}}$-linear combination of classes of smooth subvarieties.

###  0.3. Relation with Harthorne’s conjecture

In the influential article [Har74], Hartshorne introduced the following
conjecture (in a more precise form: there, the explicit bound $n>3c$ is
suggested).

######  Conjecture 0.2.

Let $X$ be a smooth subvariety of codimension $c$ in $\mathbb{P}^{n}$. If
$n\gg c$, then $X$ is a complete intersection.

Our first main result, proven in Section 1, is as follows.

######  Theorem 0.3.

Question 0.1 and Conjecture 0.2 cannot both have positive answers (even for
$c=2$).

As both Question 0.1 and Conjecture 0.2 are in some sense tameness statements
concerning algebraic cycles, we find it surprising that they cannot hold
simultaneously.

More precisely, we will show that if Conjecture 0.2 holds for $c=2$, then
Question 0.1 fails to hold for codimension $2$ cycles on $X=G(k,n)$ whenever
$k,n-k\gg 0$ (see Corollary 1.3). Our strategy of proof is as follows. A
smooth codimension $2$ subvariety $Z\subset G(k,n)$ is the zero locus of a
section of a rank $2$ vector bundle $E$ on $G(k,n)$ (by Serre’s construction
and a Barth–Lefschetz-type theorem). We embed both $\mathbb{P}^{k}$ and
$\mathbb{P}^{n-k}$ in $G(k,n)$, in many different ways. According to an
equivalent formulation of Conjecture 0.2 for $c=2$ (see Conjecture 1.1 below),
the restrictions of $E$ to all these copies of projective space should split
as direct sums of line bundles. The heart of the proof, to which §1.2 is
devoted, is to deduce that $E$ itself splits as a direct sum of line bundles.
This information constrains $c_{2}(E)$, hence the cycle class of $Z$, and this
contradicts the validity of Question 0.1.

The important particular case of unstable vector bundles is considered in
§1.3. Weaker results concerning the splitting of vector bundles of rank $\geq
3$ as direct sums of line bundles, obtained following the same strategy,
appear in §1.4.

###  0.4. A symplectic analogue

Our second main result answers positively the symplectic counterpart of
Question 0.1.

######  Theorem 0.4.

Let $(M,\omega)$ be a compact symplectic $\mathcal{C}^{\infty}$ manifold. For
all $c\geq 0$, the ${\mathbb{Q}}$-vector space $H^{2c}(M,{\mathbb{Q}})$ is
generated by fundamental classes of symplectic $\mathcal{C}^{\infty}$
submanifolds of $M$ of (real) codimension $2c$.

The proof of Theorem 0.4 is given in Section 2. We construct topological
complex vector bundles on $M$ by means of Sullivan’s rational homotopy theory
(in §2.1), and we apply the Auroux–Donaldson theorem to find sections of these
bundles whose zero loci are symplectic submanifolds (in §2.2).

We claim that Theorem 0.4 shows that there are no purely topological
obstructions to the validity of Question 0.1, in a very strong sense (and
therefore, in the light of Theorem 0.3, that it can be viewed as a negative
indication concerning the Hartshorne conjecture). To justify this claim,
consider Question 0.1 in the crucial case (as we explained above) where
$X=G(k,n)$ is a Grassmannian.

As $H^{*}(X,{\mathbb{Z}})$ is then entirely algebraic, Question 0.1 predicts
that $H^{*}(X,{\mathbb{Q}})$ is generated as a ${\mathbb{Q}}$-vector space by
classes of smooth algebraic subvarieties. For this to be true, it is necessary
that $H^{*}(X,{\mathbb{Q}})$ be generated by classes of orientable
$\mathcal{C}^{\infty}$ submanifolds. With integral coefficients, this is not
always true, and this was the original topological obstruction to the question
of Borel and Haefliger exploited by Harthorne, Rees and Thomas in [HRT74]. In
contrast, this necessary condition always holds with rational coefficients, as
was shown by Thom [Tho54, Corollaire II.30].

One can devise finer possible topological obstructions to the validity of
Question 0.1. If $H^{*}(X,{\mathbb{Q}})$ were generated by classes of smooth
algebraic subvarieties, then it would a fortiori be generated by classes of
orientable $\mathcal{C}^{\infty}$ submanifolds $Y\subset X$ whose normal
bundle $N_{Y/X}$ has a complex structure (with integral coefficients, this
obstruction is considered in [HRT74, §3]), whose tangent bundle $T_{Y}$ also
has a complex structure, and such that moreover there is an isomorphism of
complex topological vector bundles $N_{Y/X}\oplus T_{Y}\simeq T_{X}|_{Y}$.

Theorem 0.4 dashes any hope that such topological obstructions might lead to a
counterexample to Question 0.1. To see it, fix a (Kähler) symplectic form
$\omega$ on $X$, and let $Y\subset X$ be a symplectic $\mathcal{C}^{\infty}$
submanifold. Identify $N_{Y/X}$ with the $\omega$-orthogonal complement of
$T_{Y}$ in $TX|_{Y}$. Choose $\omega$-compatible complex structures on
$N_{Y/X}$ and $T_{Y}$ (they exist by [MS74, Proposition 2.6.4 (i)]). The
uniqueness of $\omega$-compatible complex structures up to homotopy (apply
[MS74, Proposition 2.6.4 (i)] again) shows that $N_{Y/X}\oplus T_{Y}$ and
$T_{X}|_{Y}$ are isomorphic as topological complex vector bundles.

##  1\. Relation between the Borel–Haefliger question and the Hartshorne
conjecture

We work over the field ${\mathbb{C}}$ of complex numbers. Let $G(k,V)$ be the
Grassmanniann of vector subspaces of dimension $k$ of a complex vector space
$V$, and set $G(k,n):=G(k,{\mathbb{C}}^{n})$. A vector bundle on an algebraic
variety is said to be decomposable if it is a direct sum of line bundles.

###  1.1. Statement

Thanks to the Barth–Lefschetz theorem [Bar70, Lar73] and Serre’s construction,
the particular case $c=2$ of Hartshorne’s Conjecture 0.2 is equivalent to the
following conjecture (see [Har74, Conjecture 6.3] and the discussion
surrounding it).

######  Conjecture 1.1.

There exists an integer $n_{0}\geq 5$ such that any rank $2$ vector bundle on
$\mathbb{P}^{n}$, with $n\geq n_{0}$, is decomposable.

Hartshorne’s original conjecture predicts that one can choose $n_{0}=7$, but
no counterexample for $n_{0}=5$ is known. We prove the following implication.

######  Proposition 1.2.

Assuming Conjecture 1.1, if $k,n-k\geq n_{0}$, any rank $2$ vector bundle on
$G(k,n)$ is decomposable.

Let $\mathcal{L}$ be the Plücker line bundle on $G(k,n)$.

######  Corollary 1.3.

If Conjecture 1.1 holds true, any smooth codimension $2$ subvariety $Z$ of the
Grassmannian $G(k,n)$ with $k,n-k\geq n_{0}$ is a complete intersection and
its cohomology class $[Z]$ is thus proportional to $c_{1}(\mathcal{L})^{2}$.
In particular, classes of smooth codimension $2$ subvarieties do not generate
over $\mathbb{Q}$ the space $H^{4}(G(k,n),\mathbb{Q})$.

###### Proof.

Since $n_{0}\geq 5$, one has $n\geq 10$. A Barth–Lefschetz-type theorem due to
Sommese (see [Som82, Proposition 3.4 and (3.6.3)]) therefore shows that if $Z$
as in the corollary, then the restriction maps $H^{l}(G(k,n),{\mathbb{Z}})\to
H^{l}(Z,{\mathbb{Z}})$ are bijective for $l\leq 2$, and hence that
$\mathrm{Pic}(Z)$ generated by $\mathcal{L}_{\mid Z}$. In particular $Z$ is
subcanonical and, as $H^{2}(G(k,n),\mathcal{L}^{i})=0$ for all $i$, the Serre
construction applies, providing a rank 2 vector bundle $E$ such that $Z$ is
the zero-locus of a section of $E$. The class of $Z$ is then equal to
$c_{2}(E)$ so the corollary follows from Proposition 1.2. ∎

###  1.2. Proof of Proposition 1.2

The Grassmannian $G(k,n)$ is swept out by $\mathbb{P}^{k}$’s and by
$\mathbb{P}^{n-k}$’s. We get a $\mathbb{P}^{k}\subset G(k,n)$ by fixing a
vector subspace $W\subset{\mathbb{C}}^{n}$ of dimension $k+1$ and by
considering the set of its hyperplanes; we will denote it by
$\mathbb{P}^{k}_{W}$. We next get a $\mathbb{P}^{n-k}\subset G(k,n)$ by fixing
a vector subspace $W^{\prime}\subset{\mathbb{C}}^{n}$ of dimension $k-1$ and
by considering the set of vector subspaces of ${\mathbb{C}}^{n}$ of dimension
$k$ containing $W^{\prime}$; we will denote it by
$\mathbb{P}^{n-k}_{W^{\prime}}$. We note that the intersection
$\mathbb{P}^{k}_{W}\cap\mathbb{P}^{n-k}_{W^{\prime}}$ is a line when
$W^{\prime}\subset W$.

Let $k,n-k\geq n_{0}$ and let $E$ be a rank $2$ vector bundle on $G(k,n)$. For
any vector subspace $W\subset{\mathbb{C}}^{n}$ of dimension $k+1$, Conjecture
1.1 gives

(1.1) $\displaystyle
E_{\mid\mathbb{P}^{k}_{W}}=\mathcal{O}(a_{W})\oplus\mathcal{O}(b_{W}),$

for some integers $a_{W},\,b_{W}$ a priori depending on $W$. Similarly, for
any vector subspace $W^{\prime}\subset{\mathbb{C}}^{n}$ of dimension $k-1$,
Conjecture 1.1 gives

(1.2) $\displaystyle
E_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}=\mathcal{O}(a^{\prime}_{W^{\prime}})\oplus\mathcal{O}(b^{\prime}_{W^{\prime}}),$

for some integers $a^{\prime}_{W^{\prime}},\,b^{\prime}_{W^{\prime}}$ a priori
depending of $W^{\prime}$.

######  Lemma 1.4.

The pair $\\{a_{W},b_{W}\\}$ is in fact independent of $W$.

###### Proof.

If $W^{\prime}\subset W$, the intersection
$\mathbb{P}^{k}_{W}\cap\mathbb{P}^{n-k}_{W^{\prime}}$ is a line
$\Delta\cong\mathbb{P}^{1}$, and by restricting (1.1) and (1.2) to $\Delta$,
we conclude that

(1.3)
$\displaystyle\\{a_{W},b_{W}\\}=\\{a^{\prime}_{W^{\prime}},b^{\prime}_{W^{\prime}}\\}.$

If $W_{1}$ and $W_{2}$ are two vector subspaces of ${\mathbb{C}}^{n}$ of
dimension $k+1$ with ${\rm dim}\,W_{1}\cap W_{2}=k-1$, by applying (1.3) to
both inclusions $W_{1}\cap W_{2}\subset W_{1}$ and $W_{1}\cap W_{2}\subset
W_{2}$, we conclude that

(1.4) $\displaystyle\\{a_{W_{1}},b_{W_{1}}\\}=\\{a_{W_{2}},b_{W_{2}}\\}.$

We finally apply the following elementary result.

######  Lemma 1.5.

Let $W_{0},\,W_{\infty}\subset{\mathbb{C}}^{n}$ be two vector subspaces of
dimension $k+1$. There exist vector subspaces $W_{i},\,\,1\leq i\leq N$ of
${\mathbb{C}}^{n}$ of dimension $k+1$ such that

${\rm dim}\,W_{0}\cap W_{1}=k-1,\,\dots,\,{\rm dim}\,W_{i}\cap
W_{i+1}=k-1,\,\,\dots,\,{\rm dim}\,W_{N}\cap W_{\infty}=k-1.$

Lemma 1.5 concludes the proof of Lemma 1.4 by iterated applications of (1.4).
∎

From now on, we denote by $\\{a,b\\}$ with $a\geq b$ the pair
$\\{a_{W},b_{W}\\}$. We now distinguish two cases.

1) Case where $a>b$. Consider the correspondence

(1.5)
---
$\textstyle{P\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{q}$$\scriptstyle{p}$$\textstyle{G(k,n)}$$\textstyle{G(k+1,n)}$

given by the universal family of $\mathbb{P}^{k}_{W}$’s, where $p$ is a
projective bundle with fiber $\mathbb{P}^{k}_{W}$ over the point $[W]\in
G(k+1,n)$. We denote by $\mathcal{L}$ and $\mathcal{L}^{\prime}$ the Plücker
line bundles on $G(k,n)$ and $G(k+1,n)$. As we have
$h^{0}(E_{\mid\mathbb{P}^{k}_{W}}(-a))=1$ for any $[W]\in G(k+1,n)$, the sheaf
$R^{0}p_{*}(q^{*}(E\otimes\mathcal{L}^{-a}))$ is a line bundle on $G(k+1,n)$,
hence isomorphic to ${\mathcal{L}^{\prime}}^{\otimes l}$ for some integer $l$.
Furthermore, the natural inclusion

$p^{*}{\mathcal{L}^{\prime}}^{\otimes l}\subset
q^{*}(E\otimes\mathcal{L}^{-a})$

is the inclusion of a line subbundle, and the quotient is a line bundle
$\mathcal{M}$ on $P$, which fits into an exact sequence

(1.6) $\displaystyle 0\rightarrow p^{*}{\mathcal{L}^{\prime}}^{\otimes
l}\rightarrow q^{*}(E\otimes\mathcal{L}^{-a})\rightarrow\mathcal{M}\rightarrow
0.$

Computing determinants, we conclude that

$\mathcal{M}=q^{*}({\rm det}\,(E\otimes\mathcal{L}^{-a}))\otimes
p^{*}{\mathcal{L}^{\prime}}^{\otimes-l}.$

Furthermore (1.6) also gives

(1.7) $\displaystyle
q^{*}c_{2}(E\otimes\mathcal{L}^{-a})=p^{*}c_{1}({\mathcal{L}^{\prime}}^{\otimes
l})\cdot(q^{*}c_{1}(E\otimes\mathcal{L}^{-a})-p^{*}c_{1}({\mathcal{L}^{\prime}}^{\otimes
l}))\,\,{\rm in}\,\,H^{4}(P,\mathbb{Z}).$

Restricting (1.7) to the fibers of $q$, which are projective spaces of
dimension $>1$, we conclude that $l=0$, so that

$\mathcal{M}=q^{*}({\rm det}\,(E\otimes\mathcal{L}^{-a})),$

and (1.6) writes

(1.8) $\displaystyle 0\rightarrow\mathcal{O}_{P}\rightarrow
q^{*}(E\otimes\mathcal{L}^{-a})\rightarrow q^{*}({\rm
det}\,(E\otimes\mathcal{L}^{-a}))\rightarrow 0.$

Next, applying $R^{0}q_{*}$ to the exact sequence (1.8), we get that $E$ is an
extension of two line bundles on $G(k,n)$, hence is decomposable.

2) Case where $a=b$. In this case, the bundle $E\otimes\mathcal{L}^{-a}$ is
trivial on the $\mathbb{P}^{k}_{W}$’s and in particular we have

(1.9) $\displaystyle q^{*}(E\otimes\mathcal{L}^{-a})\cong p^{*}F,$

for some vector bundle $F$ of rank $2$ on $G(k+1,n)$. The Grassmannian
$G(k+1,n)$ is itself swept out by projective spaces
$\mathbb{P}^{k+1}_{W^{\prime\prime}}$ of dimension $k+1$, associated to vector
subspaces $W^{\prime\prime}\subset{\mathbb{C}}^{n}$ of dimension $k+2$, and
Conjecture 1.1 implies that the restriction
$F_{\mid\mathbb{P}^{k+1}_{W^{\prime\prime}}}$ is decomposable, that is

(1.10) $\displaystyle
F_{\mid\mathbb{P}^{k+1}_{W^{\prime\prime}}}=\mathcal{O}_{\mathbb{P}^{k+1}_{W^{\prime\prime}}}(a^{\prime})\oplus\mathcal{O}_{\mathbb{P}^{k+1}_{W^{\prime\prime}}}(b^{\prime}).$

For any pair $(W^{\prime\prime\prime},W^{\prime\prime})$ of vector subspaces
of ${\mathbb{C}}^{n}$ of respective dimensions $k$ and $k+2$, there is a line
$\Delta_{W^{\prime\prime\prime},W^{\prime\prime}}\subset G(k+1,n)$
parameterizing the vector subspaces $V_{t}$ of dimension $k+1$ of
${\mathbb{C}}^{n}$ containing $W^{\prime\prime\prime}$ and contained in
$W^{\prime\prime}$. With the same notation as in (1.5), this line
$\Delta_{W^{\prime\prime\prime},W^{\prime\prime}}$ admits a canonical lift
$\widetilde{\Delta}_{W^{\prime\prime\prime},W^{\prime\prime}}\subset P$ given
by the section of $p$

$[V_{t}]\mapsto([W^{\prime\prime\prime}],[V_{t}])\in P,$

which is defined on $\Delta_{W^{\prime\prime\prime},W^{\prime\prime}}$.
Restricting equality (1.9) to the line
$\widetilde{\Delta}_{W^{\prime\prime\prime},W^{\prime\prime}}\subset P$ which
is contained in a a fiber of $q$, we get that
$F_{\mid\Delta_{W^{\prime\prime\prime},W^{\prime\prime}}}$ is trivial, and by
applying (1.10), we conclude that
$F_{\mid\mathbb{P}^{k+1}_{W^{\prime\prime}}}$ is trivial, since
$\Delta_{W^{\prime\prime\prime},W^{\prime\prime}}$ is contained in
$\mathbb{P}^{k+1}_{W^{\prime\prime}}$. In other words, considering the
incidence correspondence

---
$\textstyle{P^{\prime}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{q^{\prime}}$$\scriptstyle{p^{\prime}}$$\textstyle{G(k+1,n)}$$\textstyle{G(k+2,n)}$

for the family of $\mathbb{P}^{k+1}_{W^{\prime\prime}}$ covering $G(k+1,n)$,
we proved that

${q^{\prime}}^{*}F={p^{\prime}}^{*}G,$

for some rank $2$ bundle $G$ on $G(k+2,n)$. The triviality of $E(-a)$, which
is implied by the triviality of $F$, is thus implied by that of $G$. Iterating
the above reasoning and using the fact that $G(n-1,n)=\mathbb{P}^{n-1}$, we
finally conclude that $E(-a)$ is trivial, so Proposition 1.2 is also proved in
this case.

###  1.3. The unstable variant

An interesting and very plausible variant of Hartshorne’s Conjecture 1.1 is
the following statement.

######  Conjecture 1.6.

There exists $n_{0}^{\prime}\geq 5$ such that any unstable rank $2$ vector
bundle $E$ on $\mathbb{P}^{n}$, with $n\geq n_{0}^{\prime}$, is decomposable.

In this statement, “unstable" means “not slope stable", and this condition
says that there exists a nonzero section of $E(-a)$ for some $a$ such that
${\rm det}\,E(-a)\leq 0$. Conjecture 1.6 is important and, as explained in
[Sch80], it would have remarkable consequences, such as the existence of
topological complex vector bundles (of rank $2$) on projective space that do
not have an algebraic structure. This conjecture is studied in [GS77] and
[Siu15] but the proofs there have serious gaps, hence it is still open.

Let $G(k,n)$ be a Grassmannian as in the previous sections. As ${\rm
Pic}(G(k,n))=\mathbb{Z}\mathcal{L}$, we can speak as above of unstable rank
$2$ vector bundles $F$ on $G(k,n)$. We make the following observation:

######  Lemma 1.7.

Let $F$ be a unstable rank $2$ vector bundle on $G(k,n)$, with $k,n-k\geq 1$.
Then for any ${k+1}$-dimensional vector subspace $W\subset\mathbb{C}^{n}$, and
any $k-1$-dimensional vector subspace $W^{\prime}\subset\mathbb{C}^{n}$, the
restricted vector bundles

$F_{\mid\mathbb{P}^{k}_{W}},\,\,F_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$

are unstable.

###### Proof.

We use the notation $F(-a):=F\otimes\mathcal{L}^{\otimes-a}$. By assumption,
there exists a twist $F(-a)$ of $F$ which admits a nonzero section $s$, and is
such that ${\rm det}\,F(-a)\leq 0$. If $W$ and $W^{\prime}$ are general, the
restrictions of $s$ to $\mathbb{P}^{k}_{W}$ and
$\mathbb{P}^{n-k}_{W^{\prime}}$ are nonzero, implying that the restricted
vector bundles
$F_{\mid\mathbb{P}^{k}_{W}},\,\,F_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$ are
unstable. By upper semi-continuity, the fact that
$F_{\mid\mathbb{P}^{k}_{W}}(-a)$ has a nonzero section for general $W$ implies
the same property for any $W$, and similarly for the $W^{\prime}$’s. Hence we
conclude that
$F_{\mid\mathbb{P}^{k}_{W}},\,\,F_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$ are
unstable for any $W,\,W^{\prime}$. ∎

Using Lemma 1.7, the same arguments as in the previous section then give us
the following unstable variant of Proposition 1.2.

######  Corollary 1.8.

If Conjecture 1.6 is true, then any unstable vector bundle on $G(k,n)$, with
$k,n-k\geq n_{0}^{\prime}$, is decomposable, hence its second Chern class is a
multiple of $c_{1}(\mathcal{L})^{2}$.

###  1.4. Extension to higher rank bundles

We finally prove using similar arguments an analogous but weaker statement for
bundles of arbitrary rank $r\geq 2$ on $G(k,n)$. The next question, in the
spirit of Hartshorne’s conjectures 0.2 and 1.1, was not stated as a conjecture
by Hartshorne for lack of sufficient evidence (see the end of [Har74, §6]).

######  Question 1.9.

Fix $r\geq 2$. Does there exist an integer $n_{0}(r)\geq 5$ such that any rank
$r$ vector bundle $E$ on $\mathbb{P}^{n}$, with $n\geq n_{0}(r)$, is
decomposable?

######  Proposition 1.10.

If Question 1.9 has a positive answer for $r\geq 2$, then for any rank $r$
vector bundle $E$ on $G(k,n)$ with $n-k\geq k\geq n_{0}(r)$, the Chern classes
$c_{i}(E)$ for $i=1,\ldots,r$ satisfy

(1.11)
$\displaystyle\int_{G(k,n)}c_{i}(E)l^{n-k-i}(l^{e}\gamma_{k}-\gamma_{n-k})=0,$

where $e=n-2k$, $l=c_{1}(\mathcal{L})$ and

$\gamma_{k}\in H^{2N-2k}(G(k,n),\mathbb{Z}),\,\,{\rm resp.}\,\,\gamma_{n-k}\in
H^{2N-2n+2k}(G(k,n),\mathbb{Z}),\,\,N:={\rm dim}\,G(k,n)$

is the class of any $\mathbb{P}^{k}_{W}$, resp.
$\mathbb{P}^{n-k}_{W^{\prime}}$.

###### Proof.

The notation is as in §1.2. Under the assumptions

$n-k\geq k\geq n_{0}(r),$

a positive answer to Question 1.9 implies that the restrictions
$E_{\mid\mathbb{P}^{k}_{W}}$ and $E_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$ are
decomposable vector bundles and by the same arguments as in the proof of Lemma
1.4, we conclude that the type of the decomposition is the same for
$E_{\mid\mathbb{P}^{k}_{W}}$ and $E_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$ (and
in particular it does not depend on the choice of $W$ and $W^{\prime}$). Hence
there exist integers $a_{1},\ldots,\,a_{r}$ such that

(1.12) $\displaystyle\hskip
30.00005ptE_{\mid\mathbb{P}^{k}_{W}}=\mathcal{O}_{\mathbb{P}^{k}_{W}}(a_{1})\oplus\ldots\oplus\mathcal{O}_{\mathbb{P}^{k}_{W}}(a_{r})\textrm{
\,\,and\,\,
}E_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}=\mathcal{O}_{\mathbb{P}^{n-k}_{W^{\prime}}}(a_{1})\oplus\ldots\oplus\mathcal{O}_{\mathbb{P}^{n-k}_{W^{\prime}}}(a_{r}).$

It follows from (1.12) that

(1.13) $\displaystyle
c_{i}(E)_{\mid\mathbb{P}^{k}_{W}}=\sigma_{i}(a_{j})h^{i},\,\,c_{i}(E)_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}=\sigma_{i}(a_{j}){h^{\prime}}^{i},$

where
$h=c_{1}(\mathcal{O}_{\mathbb{P}^{k}_{W}}(1))=l_{\mid\mathbb{P}^{k}_{W}},\,\,\,h^{\prime}=c_{1}(\mathcal{O}_{\mathbb{P}^{n-k}_{W^{\prime}}}(1))=l_{\mid\mathbb{P}^{n-k}_{W^{\prime}}}$
and $\sigma_{i}$ is the $i$-th symmetric function of $r$ variables. It follows
from (1.13) that

(1.14)
$\displaystyle\int_{G(k,n)}l^{k-i}c_{i}(E)\gamma_{k}=\int_{\mathbb{P}^{k}_{W}}l^{k-i}c_{i}(E)=\sigma_{i}(a_{j})$
$\displaystyle\int_{G(k,n)}l^{n-k-i}c_{i}(E)\gamma_{n-k}=\int_{\mathbb{P}^{n-k}_{W^{\prime}}}l^{k-i}c_{i}(E)=\sigma_{i}(a_{j}),$

which implies (1.11). ∎

The following lemma shows that the equations (1.11) impose $r-1$ independent
equations to the Chern classes of $E$ which are thus severely restricted if
Question 1.9 has a positive answer.

######  Lemma 1.11.

Under the hypotheses of Proposition 1.10, the morphism

$H^{2i}(G(k,n),\mathbb{Z})\rightarrow H^{2N}(G(k,n),\mathbb{Z})$

of cup-product by the class $l^{n-k-i}(l^{e}\gamma_{k}-\gamma_{n-k})$ is
nonzero for $i\geq 2$. Equivalently, thanks to Poincaré duality, the class
$l^{n-k-i}(l^{e}\gamma_{k}-\gamma_{n-k})$ is nonzero for $i\geq 2$.

###### Proof.

It clearly suffices to prove that the cohomology class
$l^{n-k-2}(l^{e}\gamma_{k}-\gamma_{n-k})$ is nonzero in
$H^{2N-4}(G(k,n),\mathbb{Z})$. This class is the difference of the class of a
plane in $\mathbb{P}^{k}_{W}$ and the class of a plane in
$\mathbb{P}^{n-k}_{W^{\prime}}$. We construct an inclusion

$G(2,4)=G(2,V^{\prime})\subset G(k,n)$

by choosing a subspace $V\subset{\mathbb{C}}^{n}$ of codimension $n-k-2$ and a
quotient $V^{\prime}$ of $V$ of dimension $4$. This inclusion induces a
surjection $H^{4}(G(k,n),\mathbb{Z})\rightarrow H^{4}(G(2,4),\mathbb{Z})$, as
one can see by computing the pull-back to $G(2,4)$ of the second Chern class
of the universal bundle on $G(k,n)$, and thus an injection
$H_{4}(G(2,4),\mathbb{Z})\rightarrow H_{4}(G(k,n),\mathbb{Z})$. The
Grassmannian $G(2,4)$ is a quadric in $\mathbb{P}^{5}$. It contains the two
types of planes considered above and their classes are independent in
$H_{4}(G(2,4),\mathbb{Z})$; hence they remain independent in
$H_{4}(G(k,n),\mathbb{Z})$. ∎

##  2\. Construction of symplectic submanifolds

###  2.1. Construction of topological vector bundles

Let $X$ be a connected and simply connected $CW$-complex. The rationalization
of $X$ in the sense of Sullivan is a continuous map $\rho:X\to
X_{{\mathbb{Q}}}$ of connected and simply connected $CW$-complexes that
satisfies the following equivalent properties:

  1. (1)

for all $i\geq 1$, the abelian group $H_{i}(X_{{\mathbb{Q}}},{\mathbb{Z}})$ is
a ${\mathbb{Q}}$-vector space and the morphism
$\rho_{*}:H_{i}(X,{\mathbb{Q}})\to H_{i}(X_{{\mathbb{Q}}},{\mathbb{Q}})$ is an
isomorphism;

  2. (2)

for all $i\geq 1$, the abelian group $\pi_{i}(X_{{\mathbb{Q}}})$ is a
${\mathbb{Q}}$-vector space and the morphism
${\rho_{*}:\pi_{i}(X)\otimes_{{\mathbb{Z}}}{\mathbb{Q}}\to\pi_{i}(X_{{\mathbb{Q}}})\otimes_{{\mathbb{Z}}}{\mathbb{Q}}}$
is an isomorphism.

It exists and it is unique up to homotopy (see for instance [MP12, Theorem
6.1.2]).

Let $M$ be an abelian group and fix $n\geq 2$. Let $K(M,n)$ denote an
Eilenberg–Maclane $CW$-complex, whose only nontrivial homotopy group is $M$ in
degree $n$. It is a classifying space for $H^{n}(-,M)$ (see [Hat02, Theorem
4.57]). The characterization (2) shows that the rationalization of $K(M,n)$ is
$K(M\otimes_{\mathbb{Z}}{\mathbb{Q}},n)$.

######  Proposition 2.1.

Let $X$ be a finite $CW$-complex. Fix $r\geq 1$ and, for ${1\leq i\leq r}$, a
class $\alpha_{i}\in H^{2i}(X,{\mathbb{Z}})$. Then there exist $m\geq 1$ and a
complex topological vector bundle $E$ of rank $r$ on $X$ such that
$c_{i}(E)=m\cdot\alpha_{i}$ in $H^{2i}(X,{\mathbb{Z}})$ for all $1\leq i\leq
r$.

###### Proof.

Let $\mathrm{BU}(r)$ be the classifying space for complex topological vector
bundles of rank $r$, constructed as the increasing union of the complex
Grassmannians $G(r,n)$ for all $n\geq r$. Let
$\rho:\mathrm{BU}(r)\to\mathrm{BU}(r)_{{\mathbb{Q}}}$ be its rationalization.

The Chern classes induce a continuous map
$(c_{1},\dots,c_{r}):\mathrm{BU}(r)\to\prod_{i=1}^{r}K({\mathbb{Z}},2i)$. On
the one hand,
$H^{*}(\mathrm{BU}(r),{\mathbb{Z}})={\mathbb{Z}}[c_{1},\dots,c_{r}]$ (see
[MS74, Theorem 14.5]). On the other hand,
$H^{*}(K({\mathbb{Z}},2i),{\mathbb{Q}})$ is a polynomial ring in the
tautological element of $H^{2i}(K({\mathbb{Z}},2i),{\mathbb{Q}})$ (see [Ser51,
Proposition 4 p. 501]). It therefore follows from the Künneth formula that the
rationalized map

(2.1)
$(c_{1},\dots,c_{r}):\mathrm{BU}(r)_{{\mathbb{Q}}}\to\prod_{i=1}^{r}K({\mathbb{Q}},2i)$

induces an isomorphism between integral cohomology groups, and hence between
integral homology groups by the universal coefficient theorem (as these groups
are ${\mathbb{Q}}$-vector spaces). We deduce from [May83, Theorem B] that
(2.1) is a homotopy equivalence, and we denote by
$\Phi:\prod_{i=1}^{r}K({\mathbb{Q}},2i)\to\mathrm{BU}(r)_{{\mathbb{Q}}}$ a
homotopy inverse.

Define $Y:=\prod_{i=1}^{r}K({\mathbb{Z}},2i)$. By cellular approximation, we
may assume that the continuous maps $\mu_{m}:Y\to Y$ induced by multiplication
by $m$ on the coefficients ${\mathbb{Z}}$ preserve the $d$-skeleton $Y_{d}$ of
$Y$ for all $d\geq 0$.

######  Lemma 2.2.

For all $d\geq 0$, there exist a continuous map
$\Psi_{d}:Y_{d}\to\mathrm{BU}(r)$ and an integer $m_{d}\geq 1$ such that the
following diagram commutes up to homotopy:

(2.2)
$\textstyle{Y_{d}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\hskip
3.5pt\Psi_{d}}$$\textstyle{Y\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\mu_{m_{d}}}$$\textstyle{Y\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\textstyle{\ignorespaces\ignorespaces\ignorespaces\ignorespaces\mathrm{BU}(r)}$$\scriptstyle{\rho}$$\textstyle{\prod_{i=1}^{r}K({\mathbb{Q}},2i)\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\hskip
6.29996pt\Phi}$$\scriptstyle{\hskip
6.29996pt\sim}$$\textstyle{\mathrm{BU}(r)_{{\mathbb{Q}}}.}$

###### Proof of Lemma 2.2.

We argue by induction on $d$. The base case $d=0$ is obvious as both
$\mathrm{BU}(r)$ and $\mathrm{BU}(r)_{{\mathbb{Q}}}$ are connected. Assume
from now on the existence of a lift ${\Psi_{d}:Y_{d}\to\mathrm{BU}(r)}$ of the
composition
$Y\xrightarrow{\mu_{m_{d}}}Y\to\prod_{i=1}^{r}K({\mathbb{Q}},2i)\xrightarrow{\Phi}\mathrm{BU}(r)_{{\mathbb{Q}}}$
to $\mathrm{BU}(r)$, in restriction to $Y_{d}$. After possibly modifying it,
our goal is to extend this lift to $Y_{d+1}$, at the expense of precomposing
by a well-chosen multiplication map $\mu_{m}:Y\to Y$ (we will then set
$m_{d+1}:=m\cdot m_{d}$).

By obstruction theory [Ste51, Theorem 34.2], the obstruction to the existence
of such a lift lives in $H^{d+1}(Y,\pi_{d}(F))$, where $F$ is the homotopy
fiber of $\rho$. To conclude, it suffices to show that this obstruction class
is killed by pull-back by $\mu_{m}:Y\to Y$ for some $m\geq 1$.

As $\rho:\mathrm{BU}(r)\to\mathrm{BU}(r)_{{\mathbb{Q}}}$ is the
rationalization of $\mathrm{BU}(r)$, and as the homology groups of
$\mathrm{BU}(r)$, hence also its homotopy groups, are finitely generated
[Ser51, Proposition 1 p. 491], the exact sequence

$\pi_{d+1}(\mathrm{BU}(r))\to\pi_{d+1}(\mathrm{BU}(r)_{{\mathbb{Q}}})\to\pi_{d}(F)\to\pi_{d}(\mathrm{BU}(r))\to\pi_{d}(\mathrm{BU}(r)_{{\mathbb{Q}}})$

shows that $\pi_{d}(F)$ is the direct sum of a finite abelian group and of
finitely many copies of ${\mathbb{Q}}/{\mathbb{Z}}$. In addition, since the
homology groups of $Y$ are finitely generated [Ser51, Corollaire 1 p. 500],
one can verify that
$H^{d+1}(Y,{\mathbb{Q}}/{\mathbb{Z}})=\mathrm{colim}_{l\geq
1}H^{d+1}(Y,{\mathbb{Z}}/l)$ by applying the universal coefficient theorem.
Consequently, we only need to show that, for all $l\geq 1$, any class in
$H^{d+1}(Y,{\mathbb{Z}}/l)$ is killed by pull-back by $\mu_{m}:Y\to Y$ for
some well-chosen $m\geq 1$.

As ${\mathbb{Z}}/l$ is an injective ${\mathbb{Z}}/l$-module (see [Wei94,
Exercise 2.3.1]), the functor $\mathrm{Hom}(-,{\mathbb{Z}}/l)$ is exact on the
abelian category of ${\mathbb{Z}}/l$-modules. It follows that

$H^{d+1}(Y,{\mathbb{Z}}/l)=\mathrm{Hom}(H_{d+1}(Y,{\mathbb{Z}}/l),{\mathbb{Z}}/l).$

Using that $H_{d+1}(Y,{\mathbb{Z}}/l)$ is finitely generated, we see that it
remains to verify that any class in $H_{d+1}(Y,{\mathbb{Z}}/l)$ is killed by
push-forward by $\mu_{m}:Y\to Y$ for some well-chosen $m\geq 1$. Equivalently,
we must prove that any class in $H_{d+1}(Y,{\mathbb{Z}}/l)$ vanishes in the
homology of the homotopy colimit (constructed as a mapping telescope, see
[Hat02, p. 312]) of the diagram

(2.3)
$Y\xrightarrow{\mu_{2}}Y\xrightarrow{\mu_{3}}Y\xrightarrow{\mu_{4}}Y\xrightarrow{\mu_{5}}\cdots.$

This homotopy colimit identifies with the rationalization of $Y$ (to see it,
compute its homotopy groups and use characterization (2) above). Its integral
homology groups are therefore ${\mathbb{Q}}$-vector spaces, and we deduce that
its homology groups with ${\mathbb{Z}}/l$ coefficients vanish. This concludes
the proof. ∎

Let us resume the proof of Proposition 2.1. Let $f:X\to
Y=\prod_{i=1}^{r}K({\mathbb{Z}},2i)$ be a continuous map classifying the
classes $\alpha_{1},\dots,\alpha_{r}$. As $X$ is a finite $CW$-complex, we may
assume by cellular approximation that $f(X)\subset Y_{d}$ for some well-chosen
$d\geq 0$. Let $\Psi_{d}:Y_{d}\to\mathrm{BU}(r)$ and $m_{d}\geq 1$ be as in
Lemma 2.2. Let $m^{\prime}\geq 1$ be an integer killing the torsion subgroup
of $H^{*}(X,{\mathbb{Z}})$. Set $m:=m^{\prime}\cdot m_{d}$.

Let $E^{\prime}$ and $E$ be the complex topological vector bundles of rank $r$
on $X$ classified by $\Psi_{d}\,\circ f:X\to\mathrm{BU}(r)$ and
$\Psi_{d}\,\circ\mu_{m^{\prime}}\circ f:X\to\mathrm{BU}(r)$ respectively. One
has ${c_{i}(E^{\prime})=m_{d}\cdot\alpha_{i}}$ in $H^{2i}(X,{\mathbb{Q}})$ for
$1\leq i\leq r$ by commutativity of (2.2). Our choice of $m^{\prime}$ implies
that $m^{\prime}\cdot c_{i}(E^{\prime})=m\cdot\alpha_{i}$ in
$H^{2i}(X,{\mathbb{Z}})$ for $1\leq i\leq r$. As $c_{i}(E)=m^{\prime}\cdot
c_{i}(E^{\prime})$ in $H^{2i}(X,{\mathbb{Z}})$ for $1\leq i\leq r$, the proof
of the proposition is complete. ∎

######  Remark 2.3.

One can obtain many variants of Proposition 2.1 using the same argument. For
instance, it is possible to construct a complex topological vector bundle $E$
of rank $r$ on $X$ with the property that $c_{i}(E)=m^{i}\cdot\alpha_{i}$ for
$1\leq i\leq r$, by replacing everywhere the map $\mu_{m}:Y\to Y$ by the map
$\lambda_{m}:Y\to Y$ induced by multiplication by $m^{i}$ on the $i$-th factor
of $Y=\prod_{i=1}^{r}K({\mathbb{Z}},2i)$.

###  2.2. The Auroux–Donaldson theorem

The next theorem is Auroux’s extension to vector bundles [Aur97, Corollary 1]
of Donaldon’s construction of symplectic hypersurfaces [Don96] in a symplectic
manifold $(M,\omega)$ (see also [Sik98]).

######  Theorem 2.4 (Auroux–Donaldson).

Let $(M,\omega)$ be a compact symplectic $\mathcal{C}^{\infty}$ manifold. Then
there exists a complex line bundle $L$ on $M$ such that the following holds.
For all complex vector bundles $E$ on $M$, and for all $k\gg 0$, there exists
a $\mathcal{C}^{\infty}$ section of $E\otimes L^{\otimes k}$ which is
transversal to $0$ and whose zero locus is a symplectic $\mathcal{C}^{\infty}$
submanifold of $M$.

To be precise, the Auroux–Donaldson formulation assumes that the de Rham
cohomology class $\frac{[\omega]}{2\pi}$ is is in the image of the natural map
$H^{2}(M,{\mathbb{Z}})\to H^{2}(M,{\mathbb{R}})$. This restriction is well-
known to be immaterial, as indicated in [Don96, Corollary 6] and [Sik98,
Remarque p. 233]. For the convenience of the reader, we give a few more
details on this argument.

###### Proof of Theorem 2.4.

Fix a Riemannian metric $g$ on $M$. Let $(\omega_{i})_{1\leq i\leq N}$ be a
collection of closed $\mathcal{C}^{\infty}$ $2$-forms on $M$ whose de Rham
cohomology classes form a basis of $H^{2}(M,{\mathbb{R}})$. For
$\underline{t}:=(t_{1},\dots,t_{N})\in{\mathbb{R}}^{N}$ small enough, the
$2$-form $\omega_{\underline{t}}:=\omega+\sum_{i=1}^{N}t_{i}\omega_{i}$ is
still symplectic. For such values of $\underline{t}$, the almost complex
structure $J_{\underline{t}}:=J_{g,\,\omega_{\underline{t}}}$ (in the notation
of [MS17, Proposition 2.5.6]) depends continuously on $\underline{t}$, and is
$\omega_{\underline{t}}$-compatible in the sense that the pairing
$(v,w)\mapsto\omega_{\underline{t}}(v,J_{\underline{t}}(w))$ defines a
Riemannian metric on $M$.

For $\underline{t}$ small enough, one has $\omega(v,J_{\underline{t}}(v))>0$
for all nonzero tangent vectors $v$ to $M$. As the set of
$\underline{t}\in{\mathbb{R}}^{N}$ such that
$\frac{[\omega_{\underline{t}}]}{2\pi}\in H^{2}(M,{\mathbb{Q}})\subset
H^{2}(M,{\mathbb{R}})$ is dense in ${\mathbb{R}}^{N}$, we may fix from now on
a $\underline{t}$ satisfying both conditions. Set
$\omega^{\prime}:=\omega_{\underline{t}}$ and $J^{\prime}:=J_{\underline{t}}$.

As the class $\frac{[\omega^{\prime}]}{2\pi}$ is rational, some integral
multiple of it is the first Chern class of a complex line bundle $L$ on $M$.
By [Aur97, Corollary 1], there exist $\mathcal{C}^{\infty}$ sections of
$E\otimes L^{\otimes k}$ for $k\gg 0$ which are asymptotically holomorphic
(with respect to $J^{\prime}$) and transverse to $0$ in the sense of [Aur97,
Definitions 1 and 2]. Their zero loci $N_{k}\subset M$ are therefore
asymptotically $J^{\prime}$-holomorphic (see [Aur97, Proposition 1]) in the
sense that the subbundles $TN_{k}$ and $J^{\prime}(TN_{k})$ of $TM|_{N_{k}}$
are very close when $k\gg 0$ (with respect to a fixed metric on the
Grassmannian bundle associated with $TM$). The positivity of
$\omega(v,J^{\prime}(v))$ for all nonzero tangent vectors $v$ to $N_{k}$ now
implies that $\omega|_{N_{k}}$ is nondegenerate, so the $\mathcal{C}^{\infty}$
submanifold $N_{k}\subset M$ is symplectic. ∎

######  Theorem 2.5.

Let $(M,\omega)$ be a compact symplectic $\mathcal{C}^{\infty}$ manifold. For
all $c\geq 0$, the ${\mathbb{Q}}$-vector space $H^{2c}(M,{\mathbb{Q}})$ is
generated by fundamental classes of codimension $2c$ symplectic
$\mathcal{C}^{\infty}$ submanifolds of $M$.

###### Proof.

We may assume that $c\geq 1$. Choose $\alpha\in H^{2c}(M,{\mathbb{Q}})$. By
Proposition 2.1, after possibly replacing $\alpha$ by a positive integral
multiple, there exists a complex vector bundle $E$ of rank $c$ on $M$ such
that $c_{i}(E)=0$ in $H^{2i}(M,{\mathbb{Q}})$ for $1\leq i\leq c-1$, and
$c_{c}(E)=\alpha$ in $H^{2c}(M,{\mathbb{Q}})$. Let $L$ be as in Theorem 2.4.
For all $k\gg 0$, one can find a $\mathcal{C}^{\infty}$ section of $E\otimes
L^{\otimes k}$ which is transversal to $0$ and whose zero locus $N_{k}\subset
M$ is symplectic. One computes that $[N_{k}]=c_{c}(E\otimes L^{\otimes
k})=\alpha+k^{c}c_{1}(L)^{c}$, so ∎

∎
$\alpha=\frac{(k+1)^{c}}{(k+1)^{c}-k^{c}}[N_{k}]-\frac{k^{c}}{(k+1)^{c}-k^{c}}[N_{k+1}].$

## References

  * [Aur97] D. Auroux, _Asymptotically holomorphic families of symplectic submanifolds_ , Geom. Funct. Anal. 7 (1997), no. 6, 971–995.
  * [Bar70] W. Barth, _Transplanting cohomology classes in complex-projective space_ , Amer. J. Math. 92 (1970), 951–967.
  * [BD23] O. Benoist and O. Debarre, _Smooth subvarieties of Jacobians_ , Épijournal de Géométrie Algébrique, Special volume in honour of Claire Voisin, https://doi.org/10.46298/epiga.2023.10321 (2023).
  * [Ben20] O. Benoist, _On the subvarieties with nonsingular real loci of a real algebraic variety_ , preprint arXiv:2005.06424, to appear in Geometry and Topology.
  * [BH61] A. Borel and A. Haefliger, _La classe d’homologie fondamentale d’un espace analytique_ , Bull. SMF 89 (1961), 461–513.
  * [Deb95] O. Debarre, _Sous-variétés de codimension $2$ d’une variété abélienne_, C. R. Acad. Sci. Paris Sér. I Math. 321 (1995), no. 9.
  * [Don96] S. K. Donaldson, _Symplectic submanifolds and almost-complex geometry_ , J. Differential Geom. 44 (1996), no. 4, 666–705.
  * [GS77] H. Grauert and M. Schneider, _Komplexe Unterräume und holomorphe Vektorraumbündel vom Rang zwei_ , Math. Ann. 230 (1977), no. 1, 75–90.
  * [Har74] R. Hartshorne, _Varieties of small codimension in projective space_ , Bull. AMS 80 (1974), 1017–1032.
  * [Hat02] A. Hatcher, _Algebraic topology_ , Cambridge University Press, Cambridge, 2002\.
  * [Hir68] H. Hironaka, _Smoothing of algebraic cycles of small dimensions_ , Amer. J. Math. 90 (1968), 1–54.
  * [HRT74] R. Hartshorne, E. Rees and E. Thomas, _Nonsmoothing of algebraic cycles on Grassmann varieties_ , Bull. AMS 80 (1974), 847–851.
  * [Kle69] S. L. Kleiman, _Geometry on Grassmannians and applications to splitting bundles and smoothing cycles_ , Publ. Math. IHÉS (1969), no. 36, 281–297.
  * [KV23] J. Kollár and C. Voisin, _Flat pushforwards of Chern classes and the smoothability of cycles below the middle dimension_ , preprint arXiv:2311.04714, to appear in Ann. of Math.
  * [Lar73] M. E. Larsen, _On the topology of complex projective manifolds_ , Invent. Math. 19 (1973), 251–260.
  * [May83] J. P. May, _The dual Whitehead theorems_ , Topological topics, London Math. Soc. Lecture Note Ser., vol. 86, Cambridge Univ. Press, Cambridge, 1983, pp. 46–54.
  * [MP12] J. P. May and K. Ponto, _More concise algebraic topology_ , Chicago Lectures in Mathematics, University of Chicago Press, Chicago, IL, 2012.
  * [MS74] J. W. Milnor and J. D. Stasheff, _Characteristic classes_ , Annals of Mathematics Studies, vol. No. 76, Princeton University Press, Princeton, NJ; University of Tokyo Press, Tokyo, 1974.
  * [MS17] D. McDuff and D. Salamon, _Introduction to symplectic topology_ , third ed., Oxford Graduate Texts in Mathematics, Oxford University Press, Oxford, 2017\.
  * [Sch80] M. Schneider, _Holomorphic vector bundles on ${\bf P}_{n}$_, Séminaire Bourbaki (1978/79), Lecture Notes in Math., vol. 770, Springer, Berlin, 1980, pp. Exp. No. 530, pp. 80–102.
  * [Ser51] J.-P. Serre, _Homologie singulière des espaces fibrés. Applications_ , Ann. of Math. (2) 54 (1951), 425–505.
  * [Sik98] J.-C. Sikorav, _Construction de sous-variétés symplectiques (d’après S. K. Donaldson et D. Auroux)_ , no. 252, 1998, Séminaire Bourbaki. Vol. 1997/98.
  * [Siu15] Y.-T. Siu, _Splitting of unstable $2$-bundles over the complex projective $6$-space_, preprint arXiv:1505.02103.
  * [Som82] A. J. Sommese, _Complex subspaces of homogeneous complex manifolds. II. Homotopy results_ , Nagoya Math. J. 86 (1982), 101–129.
  * [Ste51] N. Steenrod, _The Topology of Fibre Bundles_ , Princeton Mathematical Series, vol. 14, Princeton University Press, Princeton, N. J., 1951.
  * [Tho54] R. Thom, _Quelques propriétés globales des variétés différentiables_ , Comment. Math. Helv. 28 (1954), 17–86.
  * [Wei94] C. A. Weibel, _An introduction to homological algebra_ , Cambridge Studies in Advanced Mathematics, vol. 38, Cambridge University Press, Cambridge, 1994\.