Salim Ouadjaout
email: salim.ouadjaout@insa-rennes.fr

Dominique Houzet
email: houzet@insa-rennes.fr

Keywords: System-level synthesis, Hardware-software codesign, Embedded software generation

Designers increasingly rely on reusing of Intellectual Property (IP) and on raising the level of abstraction to respect System-on-Chip (SoC) market characteristics. However, most hardware and embedded software codes are recoded manually from system level. This recoding step often results in new coding errors that must be identified and debugged. Thus, shorter time to market requires automation of the system synthesis from high level specifications. In this paper, we propose a design flow intended to reduce the SoC design cost. This design flow unifies hardware and software using a single high level language. It integrates hardware/software (HW/SW) generation tools and an automatic interface synthesis through a custom library of adapters. We have validated our interface synthesis approach on a hardware producer/consumer case study and on the design of a given software radiocommunication application.

1.INTRODUCTION

Technological evolution -particularly shrinking of silicon fabrication geometries-enables the integration of complex platforms in a single System on Chip (SoC). In addition to specific hardware subsystems, a modern SoC can also include sophisticated interconnects and one or several CPU subsystems to execute software. New design flows for SoC design have become essential in order to manage the system complexity in a short time-to-market. These flows include hardware/software (HW/SW) generation tools, the reuse of pre-designed Intellectual Property (IP), and interface synthesis methodologies which are still open problems requiring further research activities [START_REF] Sánchez | Embedded SW and RTOS[END_REF].

EDA tools propose their own solutions to HW/SW generation. Some use SystemC as a starting point for the hardware design, like Cynthesizer from ForteDesign [START_REF]Forte Design Systems[END_REF] or Agility Compiler from Celoxica [START_REF] Celoxica | Agility compiler user guide[END_REF]. Several tools use the C language as a starting point for both hardware and software with a custom Application Programming Interface (API) for HW/SW interfaces. It is the case of DK Design Suite from Celoxica [START_REF] Celoxica | Agility compiler user guide[END_REF] with its DSM API and CatapultC from Mentor [START_REF]CatapultC[END_REF]. In SiliconC [START_REF] Scott Ananian | SiliconC: A hardware backend for SUIF[END_REF], structural VHDL is generated for the C functions. Prototypes of the functions become the entities. There are other variants which start from Mathlab to produce both hardware and software like SPW from CoWare [START_REF] Coware | SPW and Platform Architect[END_REF]. Many design methodologies exist for the design of embedded software [START_REF] Gupta | Co-synthesis of Hardware and Software for Digital Embedded Systems[END_REF][START_REF] Pino | Software synthesis for dsp using ptolemy[END_REF][START_REF] Baladin | Hardware-Software Codesign of Embedded Systems: The POLIS Approach[END_REF]. Some are based on code generated from an abstract model (UML [START_REF]Rational[END_REF]), graphical finite state machine design environments (e.g StateCharts [START_REF] Harel | Statemate: a working environment for the development of complex reactive systems[END_REF]), DSP graphical programming environments (e.g. Ptolemy [START_REF] Pino | Software synthesis for dsp using ptolemy[END_REF]), or from synchronous programming languages (e.g Esterel [START_REF] Boussinot | The ESTEREL Language[END_REF]). A software generation from a high level model of operating system is proposed by several authors [START_REF] Grötker | System Design with SystemC[END_REF][START_REF] Desmet | Operating system based software generation for system-on-chip[END_REF][START_REF] Herrera | Systematic embedded software generation from systemc[END_REF][START_REF] Yu | Embedded Software Generation from System Level Design Languages[END_REF]. In [START_REF] Herrera | Systematic embedded software generation from systemc[END_REF], a software generation from SystemC is based on the redefinition and overloading of SystemC class library elements. In [START_REF] Grötker | System Design with SystemC[END_REF], a software-software communication synthesis approach by substituting each SystemC module with an equivalent C struct is proposed. It requires special SystemC modeling styles (i.e. with macro definitions and preprocessing switches in addition to the original specification code). In [START_REF] Yu | Embedded Software Generation from System Level Design Languages[END_REF], software is generated from SpecC with no restrictions on the description of the system model.

Several approaches have been developed to deal with IPs integration. Fast prototyping enables the productive reuse of IPs [START_REF] Pogodalla | FastPrototyping: a system design flow for fast design, prototyping and efficient IP reuse[END_REF]. It describes how to use an innovative system design flow, that combines different technologies, such as C modelling, emulation, hard Virtual Component reuse and CoWare tools [START_REF] Coware | SPW and Platform Architect[END_REF]. Prosilog's IP creator, as part of Magillem, aims to improve the integration and re-use of non-VCI compliant IPs by wrapping them into a compatible structure. This tool allows the generation of wrappers from a RTL VHDL description of the IP interface [START_REF]OCP Adoption Adds Value to Prosilog[END_REF]. The Cosy approach is based on the infrastructure and concepts developed in the VCC framework [START_REF] Brunel | Cosy communication IP[END_REF]; it defines interfaces at multiple levels of abstraction. Most of those approaches deal with low level protocol adaptation in order to integrate RTL level IPs. A few approaches provide a ready Network on Chip (NoC) to allow easy integration of communication. But these approaches require that the IPs have to be compliant with the NoC interface. Consequently, the designers have to modify the IPs codes.

All these approaches deals with system level synthesis which is widely considered as the solution for closing the productivity gap in system design. System level models are developed for early design exploration. The system specification of an embedded system is made of a hierarchical set of modules (or processes) interconnected by channels. They are described in a system level language as a set of behaviours, channel and interface declarations. Those behaviours mapped onto general or application-specific microprocessors are then implemented as embedded software and hardware. The predominant system level languages are C/C++ extensions [START_REF] Grötker | System Design with SystemC[END_REF][START_REF] Gajski | SpecC: Language and Methodology[END_REF]. We consider here the SystemC language but an other language can be used. SystemC is mainly used to model and to simulate designs at  Generation of Embedded Hardware/Software From SystemC system level. However, dedicated powerful hardware description languages like VHDL and Verilog are used for RTL. Embedded software languages like C with static scheduling or POSIX RTOS are used for embedded processors. This leads to a decoupling of behavioral descriptions and implementable descriptions. This decoupling usually requires the recoding of the design from its specification simulation, in order to meet the very different requirements of the final generated code. The recoding step often results in new coding errors that must be identified and debugged. The derivation of embedded software and hardware from system specifications described in a system level language requires to implement all language elements (e.g. modules, processes, channels and port mappings). It is known that SystemC allows the refinement for hardware synthesis, but up to now, SystemC has not been used as an embedded software language. Considering the limited memory space and execution power of embedded processors, the SystemC overhead makes the direct compilation to produce the binary code for target embedded microprocessors highly inefficient. Obviously, it is due to the large SystemC kernel included in the compiled code. This kernel introduces an overhead to support the system level features (e.g hierarchy, concurrency, communication), but these features are not necessary to the target embedded software code. In addition to direct SystemC compilation inefficiency, some cross compilers for embedded processors may only support the C language. Thus, SystemC has to be translated to C code.

To address system level synthesis, we propose in this paper a top-down methodology. Our challenge is to automate the codesign flow generating the final code for both embedded processors and hardware from a unifying high level language (SystemC). In our methodology, we have developed methods to make the co-design flow smooth, efficient and automated. These methods allow two improvements: a rapid integration of communication and a fast software generation for embedded processors with an efficient interface synthesis. The proposed methodology includes several parsing steps and intermediate models. The first main step is the communication integration based on a custom library of interface adapters that uses the Virtual Component Interface (VCI) standard from VSIA consortium [START_REF]Virtual Component Interface Standard (OCB 2 1.0[END_REF]. This library aims to perform the interface synthesis. It allows heterogeneous IPs to communicate in a plug-and-play fashion in the same system. The second main step is the generation of embedded C code from the system specification written in SystemC. Our approach proposes the use of static scheduling and POSIX based RTOS models. It enables also an automatic refinement, while [START_REF] Desmet | Operating system based software generation for system-on-chip[END_REF] requires its own proprietary simulation engine and needs manual refinement to get the software code. Our method also differs from [START_REF] Grötker | System Design with SystemC[END_REF][START_REF] Desmet | Operating system based software generation for system-on-chip[END_REF][START_REF] Herrera | Systematic embedded software generation from systemc[END_REF][START_REF] Yu | Embedded Software Generation from System Level Design Languages[END_REF] in that our high level SystemC code is translated to a C code with optimized interface synthesis. Optimization is performed according to the processors busses and the NoC as well as according to the SystemC parallel programming model (c.f. 3.4). Other recent propositions have been published in that direction [START_REF] Klingauf | Systematic Transaction Level Modeling of Embedded Systems with SystemC[END_REF].

The paper is organized as follows: in Section 2 we describe the main features of our proposed design flow. The main innovative parts of the design flow are detailed in the next two sections. The first one presents our hardware interface library and our integration methodology of functional IPs, with implementation results from a simple design example. The second one describes the translation process of SystemC elements to C code. This C code targets either a RTOS for dynamic scheduling or a standalone solution with a generated static scheduling. This translation process is validated in Section 5 with implementation results of a producer/consumer and a Code Division Multiple Access (CDMA) radiocommunication applications. This work is the result of a project started in 2001 [START_REF] Ouadjaout | Easy SoC Design with VCI SystemC Adapters[END_REF] [START_REF] Ouadjaout | VCI Interface cosynthesis[END_REF].

2.DESIGN FLOW

SoC design requires the elaboration and the use of radically new design methodologies. The main parts of a typical system level design flow are: the specification model, the partition into HW/SW elements and the implementation of the models for each element. In Figure 1 we describe the proposed top-down methodology of automatic generation of binary files from SystemC to both embedded software and hardware. The design flow starts with a high level model described in a high level programming language (SystemC). The system is described either through direct programmation or through IP reuse. We use Celoxica tools to develop, simulate, analyze and validate the SystemC code (step 1). The first SystemC description is at the functional level. The system is a set of functional IPs including functional models of architectural IPs for fast simulation. The communication between IPs uses SystemC channel mechanisms like sc_signal or sc_fifo with read() and write() primitive functions. From the Celoxica graphical tool, we select the IPs which are associated with the hardware side (the architectural IPs substituted by their already VCIcompliant version), and the IPs which are associated with the software side (the monitoring IPs, stimulating IPs, host IPs…). The remaining IPs of the system are targeted to the codesign side, as we need to optimise and well-balance hardware and embedded software to meet several stringent design constraints simultaneously: hard real-time performance, low power consumption and low resources.

Considering the software side (step 2), the SystemC IPs are directly compiled to become binary files targeted to the host processor. This set of software tasks communicate with the FIGURE 1: Top Down design flow remaining IPs contained in the FPGA platform through the PCI bus. Because software components run on processors, the SystemC abstract communication needed to describe the interconnection between the software and hardware components is totally different from the existing abstraction of wires between hardware components as well as the function calls abstraction that describes the software communication. In this part, the communication is abstracted as an API which calls PCI bus drivers through an operating system layer. The API hides hardware details such as interrupt controllers or memory and input/output subsystems. We have implemented the Message Passing Interface (MPI-2) library on the host processor and on the embedded processors of our platform [START_REF] Gropp | Using MPI-2 Advanced Features of the Message Passing Interface[END_REF]. MPI-2 is our HW/SW interface API.

The step 3 is the performing of our SCXML parser tool which allows to convert a given SystemC source code into an XML intermediate representation. The XML format is a subset of the standardized SPIRIT 2.0 format [START_REF]SPIRIT V2.0 Alpha release[END_REF]. The system is interpreted as a set of XML files. Each XML file contains the most important characteristics of a SystemC IP, such as:

-name, type and size of each in/out ports, name and type of processes declared in the constructor and also the sensitivity list of each process.

-name and type of IPs building a hierarchical IP, the names of connections between the sub-IPs, and the binding with the IP ports.

Both XML files and profiling reports from Celoxica tool are treated by our HW/SW partitioning tool (step 4) in order to partition IPs as hardware or software according to the architecture parameters and constraints. After this step we use SynDEx tool (step 5) to perform an automatic mapping, routing and static scheduling of IPs on the software and hardware architecture based on a predefined NoC topology [START_REF] Sorel | From Algorithm and Architecture Specifications to Automatic Generation of Distributed Real-Time Executives : a Seamless Flow of Graphs Transformations[END_REF]. The different SynDEx inputs are:

-a hierarchical conditioned data-flow graph of computing operations and input/output operations. The operations are just specified by the type and size of input/output data and execution time of the IPs. The XML files and profiling reports are parsed to produce these inputs. We need also to provide manually information on the non-exclusive execution of IPs in order to help Syndex optimize parallelism.

-specification of the heterogeneous architecture as a graph composed of software processors and hardware processors, interconnected through communication medias. Processors characteristics are: supported tasks, their execution duration, worst case transfer duration for each type of data on the interconnect. The profiling reports and architecture parameters are parsed to produce these inputs.

SynDex implements the IPs onto the multicomponent architecture through a heuristic mapping, routing and scheduling. After the implementation, a timing diagram gives the mapping of the different IPs on the components and the real time predicted behavior of the system. The communication links are represented in order to show all the exchanges

ADAPT ADAPT ADAPT

NoC NoC

FPGA

V V C C I I - - A A G G E E N N T T V V C C I I - - A A G G E E N N T T

VCI interface

IPs interfaces

between processors; they are taken into account in the execution time of IPs. The mapping/routing code generated by Syndex tool is then parsed (step 6) in order to manage the NoC configuration and to switch software IPs to the XML/C parser. This parser translates the XML mark-ups to C code with either RTOS calls or a static scheduling provided by SynDex tool. With our SCXML and XML/C parsers, we obtain an embedded C generation tool (SCEmbed) from SystemC. This SCEmbed tool has about 5000 C++ and JAVA code lines. This tool and its XML format can be easily adapted to a different RTOS.

The embedded C code is then treated in step 7 with the Gcc compiler in order to obtain binary executables for the embedded processors. As the C software IPs are mapped on several heterogeneous processors, they need to use a communication library (MPI-2).

In the communication integration (step 8), the identified SystemC hardware IPs are completed with our SystemC VCI adapter library. This point is detailed in the section below. Then point-to-point communication are established between the new VCI-compliant IPs and the VCI hardware IPs through the VCI NoC. We use SynDex configuration information to initialize the VCI adapters, plug the IPs on the NoC, and load the binary code of the software IPs on their corresponding processor memory. Once all the SystemC architecture is produced, we can either simulate it back in the Celoxica tool for evaluation. After validation, we continue with the implementation step.

The last hardware synthesis step plays a very important role in the methodology described above. There have been various research efforts to come up with a good hardware compiler which can generate a synthesizable HDL from high level C/SystemC specifications. The Agility compiler from Celoxica can help the generation of synthesizable VHDL from SystemC. The final product of the design flow is a set of binary files representing programs for the host processor, LEON and Microblaze (Xilinx) processors and FPGAs. These files can be loaded onto the respective components of the prototyping platform (FPGA boards), to build a prototype with a real-time communication system.

3.HW/SW INTERFACE CODESIGN

Introduction

A SoC can include specific hardware subsystems and one or several CPU subsystems to execute the software tasks. The SoC architecture includes hardware adapters (bridges or communication coprocessors) to connect the CPU subsystems to other subsystems. The HW/SW interface abstraction must hide the CPU. On the software side, the abstraction hides the CPU under a low level software layer ranging from basic drivers and I/O functionality to sophisticated operating system. On the hardware side, the interface abstraction hides CPU bus details through a hardware adaptation layer generally called the CPU interface. This can range from simple registers to sophisticated I/O peripherals including direct memory access queues and complex data conversion and buffering systems.

Hardware to Hardware interface synthesis : VCI

Adaptation Methodology We show in Figure 2 the way to establish a communication between IPs with different abstraction levels. We consider here IPs and architectural IPs. The connection can be through wires or through a NoC. The VCI adapters library aims to simplify the (re)use of functional IPs (non VCI compliant) in any SoC based on the VCI protocol. This adapter library is designed in order to change neither the IP cores nor their interface description. The generic architecture shown in Figure 3 helps to clarify the relationship between two hardware IPs connected through a sophisticated VCI NoC. The communication between heterogeneous component interfaces imposes the existence of a wrapper on each side of the communication media (bus or NoC). This wrapper behaves like a bridge which translates the RTL interface between the media and the component. These wrappers (agents) have to be compatible with VCI interface to build a standard media. Thus, an initiator wrapper is connected to VCI initiator ports of a master IP and a target wrapper is connected to VCI target ports of a slave IP.

Considering that these two VCI wrappers are available, the interface synthesis of SystemC functional IPs is a set of steps to replace a primitive channel with a refined channel in order to connect it to the wrappers. A refined channel will often have a more complex interface (e.g VCI) than the primitive channel previously used. The main step in the refining of the interfaces is to create adapters that connect the original modules to the refined channel. Adapters can help to convert the interfaces of the IPs instances into VCI interfaces. The interface refinement can be made more manageable if new interfaces are developed without making changes to their associated module. The adapter translates the transaction-oriented interface consisting of methods such as write(data) into VCI RTL level interface for hardware IPs. Figure 3 depicts the use of adapters to connect functional IPs to the NoC VCI agents. Hook arrow boxes indicate the interface provided by the adapters while the rightleftarrows square boxes represent ports. Our contribution consists in the design of VCI master adapters and VCI slave adapters which manage the VCI initiator and VCI target interfaces respectively. We have chosen a convention that each SystemC output port is an initiating port of transaction and each input port is a target port. Thus, the release of a transaction results in a non blocking write of data on the output port for a sc_signal and in a blocking write for a sc_fifo. This corresponds to the semantics of the SystemC sc_signal and sc_fifo primitive channels. Thus, initiating ports of functional IPs are connected to a master adapter and target ports are connected to a slave adapter. In this cas, several IPs may be connected to the same adapter.

The adaptation methodology approach is implemented using a micro-network stack paradigm, which is an adaptation of the OSI protocol stack. Thus the electrical, logical, and functional properties of the interconnection scheme can be abstracted.

3.2.1.Application layer

This layer describes the functional behaviour of a complex system. A system is a set of functional IPs with behavioural models, not architectural IPs such as processors or memories. The communication mechanism is performed with classical read(data) and write(data) SystemC primitives without additional parameters and no protocol implementation.

3.2.2.VCI adapter layer

The VCI adapter layer is responsible for converting an IP interface towards a lower level interface. A VCI adapter core can manage different ports of different non VCI-compliant IPs. Functional hardware IP ports are implemented as a memory segment accessed through its VCI adapter. They are directly connected to a VCI adapter dedicated to functional hardware IPs with a DMA inside it. The VCI adapter layer is composed of the following sub-layers: a)Presentation layer: This layer is responsible for translating an abstract data type port towards a SystemC synthesizable data type port.

b)Session layer:

The session layer generates a single VCI address between two ports connected to each other in the system level description. This address is divided in two fields, the most significant bits (MSB) identify the destination wrapper, and the least significant bits (LSB) identify the local offset at destination. Each agent of the NoC needs to be configured in order to know the separation position between MSB and LSB, and thus be able to perform address translation to correctly route the data to be sent.

The LSB field is itself divided first according to the target IP port addressed among the different IP ports connected to the same VCI adapter, and second according to the local address segment managed by the transport layer. VCI adapter address is finally divided in three fields:

Field-1: Agent number is the address field decoded/generated by the NoC agents and routed in the NoC. Each VCI adapter is connected to a NoC agent and all the NoC agents are numbered from 0 to N.

Field-2: Port number is the address field decoded/generated by the VCI adapter to switch data to the corresponding IP port.

Field-3: Word number is the address field decoded/generated by the transport layer. It represents the address in the memory segment of the selected port.

The address translation of each VCI adapter is configured during its connection to the NoC with its NoC agent number and its port number. Already VCI-compliant IPs have to provide configurability of addresses in order to communicate to any IP on the NoC. This configuration of IP VCI adapters is performed during VCI adapter integration step based on Syndex mapping/routing information. For already VCIcompliant IPs, addresses are provided manually as it is IP dependant. This is the second of the very few non fully automated parts of the flow.

c)Transport layer:

The basic function of the transport layer is multiple: it accepts data from the IP ports, splits them into smaller units (segments) according to the VCI master adapter data bus size, passes them to the network layer, and ensures that the pieces all arrive correctly at the other end. In addition, the transport layer is responsible of the generation of the segment number which constitutes the third field of VCI address. This layer also resequences and reassembles the messages at the destination (Slave adapter).

d)Network layer:

This layer is responsible for the identification of the initiating port. In the case of a multiport master adapter, the network layer launches an arbiter to solve the conflicts and ensures that only one port can have an access to the resource (media). The second treatment is the operation of transfers multiplexing and de-multiplexing. Multiple connections have to be scheduled in time to use the common physical VCI interface. The priority management of the different connections depends on the application constraints, provided statically or dynamically as quality of service requests (QoS).

e)DataLink layer:

The data Link layer defines the format of data on the interface and the communication protocol. It is responsible for VCI transactions.

3.2.3.Physical Layer

The physical layer is the physical way of communication. Wires are used for point-to-point connection between VCs. A NoC is used for sophisticated communications. We have synthesized an example of a simple producer/consumer on the Xilinx FPGA technology. We have used the PVCI master/slave adapters with an 8-bit data bus and a 5-bit address bus on both IPs. Each adapter unit allows two IP data bus connections of 64-bit and 32-bit size respectively with a static IP port priority management. This implementation was performed with Xilinx Virtex II xc2v3000-6 technology. We present here the post placed/routed results. We have obtained a master adapter cost of 489 units of 4-entries logic and 136 flipflop units, with a 100 MHz clock frequency. So, it occupies 1.7 % of the FPGA. The slave adapter requires 144 4-entries logic units and 204 flipflop units with the same clock frequency. It needs 0.46% of the FPGA resources. A master adapter is four times larger than a slave adapter.

Software to Software interface synthesis

For embedded software, the SystemC read(data) and write(data) are implemented with POSIX elements in the case of dynamic scheduling with a RTOS and Message Passing Interface (MPI) elements in the case of static scheduling. We have used the POSIX compliant Real-Time Embedded Multiprocessor Scheduler (RTEMS) as RTOS.

For RTEMS, the read and write primitive functions are replaced with the rtems_message_queue_receive() function and the rtems_message_queue_send() function respectively. The sc_fifo blocking read() function is implemented with the RTEMS_WAIT option set in rtems_message_queue_receive(). The non blocking sc_signal functions are implemented for RTEMS through message queues which are flushed before each data write. The non blocking read is implemented with the option RTEMS_NO_WAIT.

a RTOS-less solution, the SystemC read(data) and write(data) are implemented as one-sided Remote Memory Access (RMA) with the MPI MPI_put(data) primitive only. The blocking mechanism for sc_fifo is implemented with the MPI_wait() primitive which waits for an acknowledgment.

Software to Hardware interface synthesis

For software IP on embedded CPUs, communication with the NoC VCI agent is managed with dual-ported memory buffers and DMA from its VCI adapter (dedicated to the CPUs) directly connected to this dual-ported memory. The DMA is controlled by software driver subroutines overloading MPI or RTEMS message queues.

In the case of host processor, the read(data) and write(data) SystemC primitives are overloaded in order to call the PCI driver services through MPI calls. This software driver configures the hardware DMA which manages the data transactions between host memory and the NoC on the prototyping board through the VCI/PCI bridge.

Using one-sided RMA is an efficient implementation solution of MPI [25][28] and the SystemC programming model is also very well suited to RMA implementation as sc_signal reads and writes are not correlated. In practice, efficiency of HW/SW interfaces is obtained with a direct integration of SystemC high level communication library in hardware, that is by a joint optimisation of the implementation of the SystemC programming model with the MPI_put() and MPI_wait() primitives (RMA model) as well as with the underlying NoC design. The RMA mechanism is limited to write-only transfers between IPs allowing the design of a specific NoC optimised for those transfers with DMA. This approach is similar to the joint optimisation of compilers and microarchitectures of microprocessors.

We have designed optimised network interfaces for two custom NoC [START_REF] Evain | ¹Spider : A CAD Tool for Efficient NoC Design[END_REF] with write-only communications, connected to Microblazes, LEONs and PowerPCs processors through their dedicated ports. The MPI_put() primitive needs two I/O access to configure the DMA of the network interface and to launch the DMA transfer in the NoC. Thus the MPI_put() takes only 8 processor clock cycles : 6 clock cycles to prepare the DMA configuration and 2 clock cycles for I/O access. In that case the result for the SystemC sc_signal write() primitive is 25 clock cycles of overhead comprising two MPI_put() executions (one for the control and one for the data), that is 16 clock cycles, and 9 clock cycles to prepare the data to be transferred. Also there is no overhead for the SystemC sc_signal read() which is only a local variable access due to the RMA mechanism.

For comparison, the main differences between MPI RMA subset and DSM API from Celoxica presented in Table 1 is that the MPI_put is a non blocking mechanism which in conjunction with MPI_Wait can implement a blocking mechanism, compared to the DsmWrite and DsmRead which are only blocking mechanisms. Also the DSM API is a twosided communication compared to the one-sided RMA subset.

4.GENERATION OF EMBEDDED C CODE

In modern complex SoCs, the software as an integral part of the SoC is gaining more and more importance. At the system level, the system is composed of a set of hierarchical behaviors connected together through channels. However, for the implementation, many designers use a task-based approach, where the tasks are scheduled by a real time kernel. A whole system design is composed of a set of globally asynchronous/locally synchronous reactive processes that concurrently perform the system functionalities. Inside the SystemC process code, only wait() primitives are allowed and processes lack a sensitivity list except for one signal which is considered as a clock. Therefore, a process will only block when it reaches a wait(). These restrictions that we have required are only for the code involved in the embedded HW/SW partitioning process. They help our SCEmbed tool to generate the embedded C code [START_REF] Ouadjaout | degree in computer science from the National Institute of Computers (INI), Algeria[END_REF]. These restrictions on SystemC coding are also required by Celoxica tools for the SystemC synthesis.

The XML format used by the XML/C parser is easily adaptable for a new target RTOS. The main idea behind is to redefine the SystemC class library elements for the new target RTOS. The original code of these IPs calls the SystemC kernel functions to support process concurrency and communication. The new code calls the embedded RTOS functions that implement the equivalent functionality. Thus, SystemC kernel functions are replaced either by typical RTOS functions or through direct generation of a statically scheduled code. The functional behavior is not modified during the hardware, software and interfaces generation.

We illustrate the C generation process for the RTOS target with a Producer/Consumer example. The SystemC main code named sc_main() is converted to the RTEMS RTOS main code "init". The channels are implemented with message queues for blocking sc_fifo channels and shared variables for non blocking sc_signal channels. The clock in the code is converted into a task sending an event value broadcasted on a message queue. All the tasks read this clock message queue for there synchronization. SystemC concurrent processes need to be converted into RTOS-based tasks. We instantiate the child tasks in a parent one corresponding to the SC_MODULE in the system specification. This step is illustrated by our example in Figure 4. The producer and the consumer instances are converted into Tprod and Tcons parent tasks. In RTEMS, each parent task (SC_MODULE in systemC) launches the child tasks (processes in SystemC) and an additional task which is responsible for inter-process communication. This task is created to manage sc_out ports writing delay corresponding to the behavioral delay of the SystemC write function (the data are validated after the wait event). The RTEMS equivalent code of the SystemC Producer is shown in Figure 5.

At the system level, synchronization is implemented using channels or SystemC events. During the generation process, the RTOS model provides routines to replace the SystemC synchronization primitives.

FIGURE Producer RTEMS code

In the case of POSIX generation, synchronization between tasks is managed by semaphores for sc_signal implementation with global shared variables. A special clock management task is generated which schedules the two-step signal assignment process in order to respect the semantic of sc_signal. All the signal assignments are performed simultaneously after all the processes are stopped on a wait() instruction. The wait() instruction is implemented by a semaphore synchronization. The clock task is waiting for all the tasks which are sensitive to the same clock to stop on a wait instruction. Then the second step is performed by this clock management task, which corresponds to the assignment of all the shared global variables with the temporary variables assigned by the different blocked tasks. These blocked tasks are then freed and can read the shared global variables which are now updated. This mechanism is generated for each independent clock in the whole system. When different tasks are mapped on different processors, we assume that they communicate through asynchronous sc_fifo channels. Otherwise, the clock management tasks of the different processors have to be synchronized before the assignment of the shared global variables.

The second approach uses a RTOS-less static scheduling. In this solution, the SystemC scheduler is replaced by our custom simulation engine optimized for embedded applications. This scheduler is called from each wait() instruction or from sc_fifo blocking read() or write() functions. This scheduler also manages the synchronization of clock sensitive tasks with barrier primitives.

A channel implementation library is provided for all the solutions. Up to now, only primitive channels are available (sc_signal, sc_fifo). There are three versions of implementation for each channel: SW/SW, HW/HW and SW/HW. SW/SW channels are direct shared variables or message queues implementation. HW/HW channels are RTL level NoC wrappers. SW/HW are C drivers for embedded processors connected to the NoC.

5.APPLICATION EXAMPLE

In order to evaluate the proposed technique, two designs have been experimented for the SW part in this section. The first one is a simple consumer/producer case with two SystemC components linked together. The second one, a more realistic case, is a CDMA radiocommunication example. The consumer/producer system description has about 86 SystemC code lines and the CDMA system description has about 976 SystemC code lines. the CDMA includes 7 modules with 8 concurrent processes. Both examples have been implemented in a SPARC-based platform that includes 1MB SDRAM and a LEON2 processor synthesized on one 4Mgate Xilinx FPGA with 128 KBytes of RAM. The open source POSIX-compliant RTEMS operating system has been selected as the target embedded RTOS.

The CDMA system has 7 modules: the top (CDMA), one module that generates samples, three modules that compute the QPSK modulation, the THR and the interleaving, one that models the real environment channel behavior by introducing noise, and the last ones that do the reverse treatment that is deinterleaving, ITHR and demodulation. All the modules work in a pipelined dataflow way. Several channel models have been implemented with our design flow. The CDMA application example uses one of them: a non blocking channel (the sc_signal channel). The proposed channel models have different implementations depending on the HW/SW partition. Several experiments have been performed with semaphores, mutex condition variables and signals in order to synchronize threads with RTEMS.

Table 2 shows the code size of the different codes on the different operating systems. Table 3 presents there binary size and Table 4 their average execution time per treatment iteration. In Table 2, the number of lines of the generated embedded C code is nearly the double for the first simple case which includes 27% of SystemC primitives. For the CDMA, the generated code size is nearly half more important with only 13% of SystemC primitives. The size of the embedded C generated code is directly linked to the number of SystemC elements included in the original code. As each SystemC primitive is translated with a set of embedded C instructions, a large proportion of read(), write(), wait() and others primitives can result in an important size. However, the increase of the generated code size remains low. Moreover, this generated C code is entirely "readable" and can be completed or optimized manually.

The Table 3, the size of the statically scheduled code for embedded processor is nearly ten times lower than the RTOS one. Thus it is more interesting to use our RTOS-less for embedded processors. For the Linux implementation, the kernel is not included in the code, thus its size is lower than for the standalone one which include its own kernel.

In Table 4, the code execution time with static scheduling is nearly 60 times faster than the RTOS one. We have to consider here that the CDMA application highly communicates and thus highly requests RTOS services with context switching for each communication. Nevertheless we can conclude that RTOS implementation of SystemC elements is not the best solution when static scheduling can be used. Secondly, the validation of the embedded software on a host computer, through direct POSIX execution, obtains comparable execution times compared to SystemC execution. It is thus possible to validate the produced C code before loading it on the target embedded processor. Also we obtain better execution times for a dedicated static scheduling that is nearly ten times faster than pure SystemC execution times. It is thus possible to evaluate more rapidly the whole SystemC model by parsing it in C and execute it instead of using pure SystemC simulations. This is possible only for the functional embedded code.

The results collected in the tables 2, 3 and 4 show the usability of POSIX and static scheduling as embedded C modeling solutions.

We have also experimented different multiprocessor implementations in order to evaluate the impact of HW/SW interface synthesis in term of time overhead. This overhead includes software delays from device drivers and hardware delays due to the NoC crossing. We have experimented several configurations with 1, 2, 4 and 7 processors connected with a one-dimension linear NoC with two processors per node. The speedup obtained is presented on Figure 6. The reduced overhead of software and hardware interfaces (25 clock cycles for a write) combined with the NoC crossing time of almost one clock per NoC node crossed makes the impact of communication low compared to the execution time of the CDMA functions on the different processors. We obtain a speedup of 1.8 with 2 processors and 5 with 7 processors. These results show the low implications of such a higher level interface approach.

6.CONCLUSION

This paper deals with the idea of unifying the use of SystemC to implement both hardware and embedded software. This technique reduces the embedded system design cost with a platform based HW/SW codesign methodology.

The virtual component interfacing is a key aspect of HW/SW codesign. We have shown that it improves significantly the SoC design process by enabling early verification, reusability, and interoperability. We provide VCI adapters intended to tackle a number of technical challenges confronting SoC designers. Each adapter is divided into several layers and may be connected to several ports and/or several IPs. Only transport, network and datalink layers can be implemented as hardware. The presentation and session layers of the VCI adapters are only used for the functional behaviour of the system.

The proposed methodology uses the redefinition of SystemC class library construction elements to generate the embedded software. A first solution is to replace each SystemC element by typical RTOS functions and MPI primitives. A second solution, which is complementary, is to generate a standalone statically scheduled C code which exhibits better results. This method is independent of the selected RTOS and communication API; any of them which is POSIX compliant can be supported by simply adapting the corresponding library. Future works concern the full support of the SPIRIT standard as well as the improvement of Syndex mapping and routing solution.

3 HW

 3

FIGURE 2 :

 2 FIGURE 2 : VCI connections of non VCI IPs through VCI adapters

FIGURE 3 :

 3 FIGURE 3 : Layers between heterogeneous interfaces of two sets of IPs

  "wire" point-to-point connection (b) NoC connection

FIGURE 4 :

 4 FIGURE 4: from SystemC main code to RTEMS code

FIGURE 6 :

 6 FIGURE 6: speedup of CDMA application

TABLE 1 :

 1 DSM AND RMA MPI SUBSET COMPARISON

	DSM	MPI
	DsmInit()	MPI_Init()
	DsmExit()	MPI_Finalize()
	DsmWrite() & DsmRead()	MPI_Put() & MPI_Wait()
	DsmPortS2HOpen()	--
	--	MPI_Barrier()

TABLE 2 :

 2 LINE NUMBER OF PROD/CONS AND CDMA SOURCE CODE

		SystemC	POSIX	RTEMS	POSIX	Static C	Static C
		Linux	Linux	LEON	LEON	Linux	LEON
	Prod/Cons	86	130	203	161	-	-
	CDMA	976	1350	1479	1387	950	950
		TABLE 3 : BINARY CODE SIZE OF PROD/CONS AND CDMA
		SystemC	POSIX	RTEMS	POSIX	Static C	Static C
		Linux	Linux	LEON	LEON	Linux	LEON
	Prod/Cons	592 K	14K	106K	83K	-	-
	CDMA	1.8 M	32K	119K	97K	188K	12K
		TABLE 4 : EXECUTION TIME OF PROD/CONS AND CDMA
		SystemC	POSIX	RTEMS	POSIX	Static C	Static C
		Linux	Linux	LEON	LEON	Linux	LEON
	Prod/Cons	43 µs	81µs	2.43 ms 1.85 ms	-	-
	CDMA	170 µs	310 µs 12.5 ms	9.2 ms	17 µs	153 µs


Angela Pasquale

Maddala Sundari

UNCERTAINTY PRINCIPLES FOR THE SCHR ÖDINGER EQUATION ON RIEMANNIAN SYMMETRIC SPACES OF THE NONCOMPACT TYPE

Keywords: 2010 Mathematics Subject Classification. Primary 43A85; Secondary 35R01, 58Jxx Uncertainty principle, Schrödinger equation, Helgason-Fourier transform, Beurling theorem, Hardy theorem

come

Uncertainty principles for the Schrödinger equation on Riemannian symmetric spaces of the noncompact type

Introduction

Consider the initial value problem for the time-dependent Schrödinger equation on a Riemannian symmetric space of the noncompact type X:

i∂ t u(t, x) + ∆u(t, x) = 0 u(0, x) = f (x) (S)
where ∆ denotes the Laplace-Beltrami operator on X. In [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF], Sagun Chanillo initiated the study of certain uniqueness properties for the solutions of (S) that are related with the uncertainty principle.

According to this principle, the solution u(t, •) must be identically zero at all times t whenever the initial condition f and the solution at a certain time t 0 = 0 are simultaneously very rapidly decreasing. The case considered by Chanillo corresponds to Riemannian symmetric spaces of the form X = G/K where G is a noncompact connected semisimple Lie group possessing a complex structure and K is a maximal compact subgroup of G. Moreover, in [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF] the initial condition f is assumed to be K-invariant, which ensures that the solution itself is K-invariant. Some related articles in the Euclidean setting are [START_REF] Ionescu | Uniqueness properties of solutions of Schrödinger equations[END_REF], [START_REF] Escauriaza | Hardy's uncertainty principle, convexity and Schrödinger evolutions[END_REF], [START_REF] Escauriaza | The sharp Hardy uncertainty principle for Schrödinger evolutions[END_REF], [START_REF] Escauriaza | Uncertainty principles of Morgan type and Schrödinger evolutions[END_REF] and [START_REF] Cowling | The Hardy uncertainty principle revisited[END_REF]; for the Heisenberg group [START_REF] Said | Uniqueness of solutions to the Schrödinger equation on the Heisenberg group[END_REF].

In this paper, we consider the inital value problem (S) on arbitrary Riemannian symmetric spaces X of the noncompact type and not-necessarily K-invariant initial data f ∈ L 2 (X). We show that if f and the solution u(t 0 , •) at some time t 0 > 0 satisfy a suitable Beurling type condition, then u(t, •) = 0 for all t ∈ R. This describes an uncertainty principle because of the kind of relation one gets between the Fourier transforms of u t = u(t, •) and the initial condition f ; see (37). Our result in particular also implies the uniqueness property of solutions for the Schrödinger equation (S) proved by Chanillo using Hardy type conditions.

On X, the rapid decrease of a function is measured by means of exponential powers of the distance function d on X induced by the Riemannian metric. If o = eK denotes the base point in X, we set σ(x) := d(o, x). The estimates are also in terms of the elementary spherical function of spectral parameter 0, denoted by Ξ. We denote by C(R : L 2 (X)) the space of continuous functions t → u(t, •) from R to L 2 (X). We refer to section 2.4 for the precise definitions. Our main result is the following theorem.

Theorem 1.1. Let X be a Riemannian symmetric space of the noncompact type and let f ∈ L 2 (X). Let u(t, x) ∈ C(R : L 2 (X)) denote the solution of (S) with initial condition f . If there is a time t 0 > 0 so that X X |f (x)||u(t 0 , y)|Ξ(x)Ξ(y)e σ(x)σ(y) 2t 0 dx dy < ∞ ,

then u(t, •) = 0 for all t ∈ R.

The proof of Theorem 1.1 is given in section 4.3. It is based on a reduction to a Euclidean situation by means of the Radon transform. This is a powerful technique that is commonly used to attack problems related to the uncertainty principle on symmetric spaces as well as on Euclidean spaces; see for instance [START_REF] Sengupta | The uncertainty principle on Riemannian symmetric spaces of the noncompact type[END_REF][START_REF] Sengupta | An analogue of Hardy's theorem for semi-simple Lie groups[END_REF][START_REF] Sarkar | Beurling's theorem and characterization of heat kernel for Riemannian symmetric spaces of noncompact type[END_REF][START_REF] Sarkar | Beurling's theorem for Riemannian symmetric spaces[END_REF]. In our situation, the important feature is that for functions satisfying [START_REF] Anker | A basic inequality for scattering theory on Riemannian symmetric spaces of the noncompact type[END_REF], the composition of the Radon transform and a Euclidean Fourier transform gives the Helgason-Fourier transform. A Beurling theorem for the Helgason-Fourier transform has been proved by Sarkar and Sengupta (see [START_REF] Sarkar | Beurling's theorem for Riemannian symmetric spaces[END_REF], Theorem 4.1), under the assumption f ∈ L 1 (X) ∩ L 2 (X). However, unlike the Euclidean case treated in section 3 below, we cannot deduce our uniqueness theorem from Beurling's theorem on Riemannian symmetric spaces. In fact, in the Euclidean situation, the moduli of the initial value function f (x) and of the solution u(t, x) are (up to constants) equal to those of a Fourier transform pair (h, h). So Beurling's theorem for (h, h) yields the required uniqueness for the Schrödinger solution. See Corollary 3.5. A similar property does not hold for general Riemannian symmetric spaces. This is a consequence of the lack of duality between the Helgason-Fourier transform and its inverse. One can in part recover this duality for K-invariant functions on Riemannian symmetric spaces G/K with G complex. In this case, one can work on a maximally flat geodesic submanifold, where the Helgason-Fourier transform reduced essentially to a Euclidean Fourier transform. This is the approach used in [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF].

The classical version of Beurling's theorem on R n is among the strongest qualitative uncertainty principles. By this, we mean theorems which allow to conclude that f = 0 by giving quantitative conditions on f and its Fourier transform f . For instance, Beurling's theorem implies the qualitative uncertainty principles of Gelfand-Shilov, Cowling-Price and Hardy. Following this line, in section 5 we prove that the uniqueness property stated in Theorem 1.1 implies uniqueness properties respectively of Gelfand-Shilov, Cowling-Price and Hardy type, for the solution of the Schrödinger equation on a Riemannian symmetric space.

Finally, we study more closely the Hardy type conditions. Let α and β be the exponents measuring respectively the very rapid decay of the initial condition f and the solution u t 0 at a time t 0 > 0. Then the uniqueness property is proven to hold when the condition 16t 2 0 αβ > 1 is satisfied. The value of t 0 is shown to be optimal. More precisely, in Theorem 5.9 we prove that, under the additional assumption that G admits a complex structure, the K-invariant initial conditions f for which the uniqueness property fails in the case 16t 2 0 αβ = 1 are precisely the constant multiples of an explicitly given function. like to thank the referee for a very careful reading of our manuscript, constructive suggestions and some simplifications of our original arguments.

Notation and preliminaries

2.1. Riemannian symmetric spaces of the noncompact type and their structure. Let X be a Riemannian symmetric space of the noncompact type. Then X = G/K where G is a noncompact, connected, semisimple, real Lie group G with finite center and K is a maximal compact subgroup of G. Let g be the Lie algebra of G and let k (⊂ g) be the Lie algebra of K. We have the Cartan decomposition g = k ⊕ p, where p is the subspace of g which is orthogonal to k with respect to the Killing form B of g. Then p can be identified with the tangent space to X at the base point o = eK. We fix a maximal abelian subspace a of p. We denote by a * the (real) dual space of a and by a * C its complexification. The Killing form B is a (positive definite) inner product on p and hence on a.

For H 1 , H 2 ∈ a we set H 1 , H 2 := B(H 1 , H 2 ) and |H 1 | := H 1 , H 1 1/2
. We extend this inner product to a * by duality by setting λ, µ := H λ , H µ if H λ is the unique element of a so that H, H λ = λ(H) for all H ∈ a. The C-bilinear extension of •, • to a * C will be indicated by the same symbol.

The set of (restricted) roots of the pair (g, a) is denoted by Σ. It consists of all α ∈ a * for which the vector space g α := {X ∈ g : [H, X] = α(H)X for every H ∈ a} contains nonzero elements. The dimension m α of g α is called the multiplicity of the root α. We shall adopt the convention that m 2α = 0 if 2α is not a root. The subset of a on which all roots vanish is a finite union of hyperplanes. We can therefore choose Y ∈ a so that α(Y ) = 0 for all α ∈ Σ. Put Σ + := {α ∈ Σ : α(Y ) > 0}. Then Σ + is a system of positive roots, and Σ is the disjoint union of Σ + and -Σ + . A root α ∈ Σ is said to be indivisible if α/2 / ∈ Σ. We denote by Σ 0 the set of indivisible roots and set Σ + 0 := Σ + ∩Σ 0 . The half-sum of the positive roots counted with multiplicites is denoted by ρ: hence

ρ = 1 2 α∈Σ + m α α . (2)
The set a + := {H ∈ a : α(H) > 0 for all α ∈ Σ + } is an open polyhedral cone called the positive Weyl chamber. The corresponding Weyl chamber in a * is a * + := {λ ∈ a * : λ, α > 0 for all α ∈ Σ + }. Let exp : g → G be the exponential map of G, and set A := exp a and A + := exp a + . Then A is an abelian subgroup of G that is diffeomorphic to a under exp. The inverse diffeomorphism is denoted by log.

The Weyl group W of the pair (g, a) is the finite group of orthogonal transformations of a generated by the reflections r α with α ∈ Σ, where

r α (H) := H -2 α(H) α, α H α , H ∈ a .
The Weyl group action extends to A via the exponential map, to a * by duality, and to a * C by complex linearity.

Set n := ⊕ α∈Σ + g α . Then N := exp n is a simply connected nilpotent subgroup of G. The subgroup A normalizes N . The map (k, a, n) → kan is an analytic diffeomorphism of the product manifold K ×A×N onto G. The resulting decomposition G = KAN = KN A is called the Iwasawa decomposition of G. Thus, for g ∈ G we have g = k(g) exp H(g)n(g) for uniquely determined k(g) ∈ K, H(g) ∈ a and n(g) ∈ G. One can prove that

|H(ak)| ≤ | log a| (3)
for all a ∈ A and k ∈ K.

Let M be the centralizer of A in K and set B = K/M . Then the map A : X × B → a is defined by A(gK, kM ) := -H(g -1 k) .

(4) Besides the Iwasawa decomposition, we will also need the polar decomposition G = KAK: every g ∈ G can be written in the form g = k 1 ak 2 with k 1 , k 2 ∈ K and a ∈ A. The element a is unique up to W -invariance.

2.2. Normalization of measures and integral formulas. We shall adopt the normalization of measures as in [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF], Ch. II, §3.1. In particular, the Haar measures dk and dm on the compact groups K and M are normalized to have total mass 1. The Haar measures da and dλ on A and a * , respectively, are normalized so that the Euclidean Fourier transform

(F A f )(λ) := A f (a)e -iλ(log a) da , λ ∈ a * , (5)
of a sufficiently regular function f : A → C is inverted by

f (a) = a * (F A f )(λ)e iλ(log a) dλ , a ∈ A . (6)
The Haar measures dg and dn of G and N , respectively, are normalized so that dg = e 2ρ(log a) dk da dn . Moreover, if U is a Lie group and P is a closed subgroup of U , with left Haar measures du and dp, respectively, then the U -invariant measure d(uP ) on the homogeneous space U/P (when it exists) is normalized by

U f (u) du = U/P P f (up) dp d(uP ) . (7)
This condition normalizes the G-invariant measure dx = d(gK) on X = G/K and fixes the Kinvariant measure db = d(kM ) on B = K/M to have total mass 1.

Corresponding to the Iwasawa and the polar decompositions, we have the integral formulas

X f (x) dx = G f (g • o) dg = K A N f (kan • o)e 2ρ(log a) dk da dn (8) = c K A + f (ka • o)δ(a) dk da (9)
where

δ(exp H) = α∈Σ + (sinh α(H)) mα = e 2ρ(H) α∈Σ + 1 -e -2α(H) 2 mα , H ∈ a + ( 10
)
and c is a suitable positive constant.

2.3.

Invariant differential operators on X and the Laplace-Beltrami operator. Let D(X) denote the commutative algebra of invariant differential operators on X which are invariant under the action of G on X by left translations. As a Riemannian manifold, a symmetric space of the noncompact type X = G/K is endowed with a Laplace-Beltrami operator ∆ defined by ∆f = div

• grad f for f ∈ C ∞ (X). It turns out that ∆ is a self-adjoint differential operator on L 2 (X) belonging to D(X). Let λ ∈ a * C and b ∈ B. Then the function e λ,b : X → C defined by e λ,b (x) = e (iλ+ρ)(A(x,b)) , x ∈ X , (11)
is an eigenfuntion of ∆. In fact,

∆e λ,b = -( λ, λ + ρ, ρ )e λ,b . (12)
We refer to [START_REF] Helgason | Groups and geometric analysis. Integral geometry, invariant differential operators, and spherical functions[END_REF], Ch. II, for additional information.

2.4. K-invariant functions. Functions f : X → C can be identified with right K-invariant functions on G, i.e. with functions f : G → C so that f (gk) = f (g) for all g ∈ G and k ∈ K.

Likewise, K-invariant functions on X can be identified with K-bi-invariant functions on G, i.e. with functions f :

G → C so that f (k 1 gk 2 ) = f (g) for all g ∈ G and k 1 , k 2 ∈ K.
In turn, because of the polar decomposition G = KAK = KA + K, a K-bi-invariant function on G can be identified with its W -invariant restriction to A or with its restriction to A + . The Riemannian distance from the origin o, defined by σ(x) = d(x, o), is an example of K-invariant map on X. According to the above identifications, we shall sometimes write σ(g) instead of σ(g

• o) for g ∈ G. If x = g • o and g = k 1 exp Hk 2 with g ∈ G, H ∈ a and k 1 , k 2 ∈ K, then σ(x) = σ(g) = σ(exp H) = |H|. (13)
The function σ satisfies the following inequalities:

σ(gh) ≤ σ(g) + σ(h) , g, h ∈ G , (14)
σ(an) ≥ σ(a) , a ∈ A , n ∈ N . (15)
Another K-invariant function on X we shall employ is the spherical function Ξ of spectral parameter 0. It is defined by

Ξ(x) = B e 0,b (x) db = K e -ρ(H(gk)) dk , x = g • o ∈ X. (16)
It is a real analytic function and, writing Ξ(g) instead of Ξ(g • o), it satisfies the following properties:

0 < Ξ(g) = Ξ(g -1 ) ≤ 1 , g ∈ G , (17)
K Ξ(g 1 kg 2 ) dk = Ξ(g 1 )Ξ(g 2 ) , g 1 , g 2 ∈ G , (18)
e -ρ(H) ≤ Ξ(a) ≤ e -ρ(H) (1 + |H|) d , a = exp H ∈ A + , (19)
where d = |Σ + 0 | is the cardinality of the set of positive indivisible roots. The properties of the functions σ and Ξ can be found in [START_REF] Gangolli | Harmonic analysis of spherical functions on real reductive groups[END_REF], §4.6 and §6.2.

The Helgason-Fourier transform and the Radon transform.

A reference for this section is [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF], Ch. III. The Helgason-Fourier transform of a sufficiently regular function f : X → C is the function Ff defined by

Ff (λ, b) = X f (x)e -λ,b (x) dx = AN f (kan • o)e (-iλ+ρ)(log a) da dn (20)
for all λ ∈ a * C and b = kM ∈ B for which this integral exists. The Plancherel theorem states that the Helgason-Fourier transform F extends to an isometry of

L 2 (X) onto L 2 (a * + × B, |c(λ)| -2 db dλ). The function c(λ) occurring in the Plancherel density is Harish-Chandra's c-function. It is the meromorphic function on a *
C given explicitly by the Gindikin-Karpelevich product formula:

c(λ) = c 0 α∈Σ + 0 c α (λ) (21)
where

c α (λ) = 2 -iλα Γ(iλ α ) Γ iλα 2 + mα 4 + 1 2 Γ iλα 2 + mα 4 + m 2α 2 (22)
and the constant c 0 is given by the condition c(-iρ) = 1. In [START_REF] Sengupta | The uncertainty principle on Riemannian symmetric spaces of the noncompact type[END_REF] we have employed the notation

λ α := λ, α α, α (23)
for α ∈ Σ and λ ∈ a * C . Observe that if f ∈ L 2 (X) then, by the Plancherel theorem, for almost all λ ∈ a * we have

Ff (λ, •) ∈ L 2 (B).
The Helgason-Fourier transform Ff of a function f ∈ L 1 (X) is almost everywhere defined. More precisely, there exists a subset B ⊂ B (depending on f ) with B \ B of zero measure, such that Ff (λ, b) is defined for each λ ∈ a * . In fact, Ff (λ, b) is defined and holomorphic for λ in a small tube domain around a * in a * C . It turns out that F is injective on L 1 (X). Furthermore, as in the Euclidean case, there is an inversion formula for functions f ∈ L 1 (X) with Ff ∈ L 1 (a * × B, |c(λ)| -2 db dλ): for almost all x ∈ X, we have

f (x) = 1 |W | a * ×B Ff (λ, b)e λ,b (x) db dλ |c(λ)| 2 , ( 24
)
where |W | denotes the cardinality of the Weyl group W . By identifying the space G/M N of horocycles on X with B × A, one can define the Radon transform of a sufficiently regular function f : X → C as the function Rf defined by

Rf (b, a) = e ρ(log a) N f (kan • o) dn (25)
for all b = kM ∈ B = K/M and a ∈ A for which this integral exists. See [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF], p. 220 or [START_REF] Eguchi | Some properties of Fourier transform on Riemannian symmetric spaces[END_REF]. If f ∈ L 1 (X), then the integral defining Rf (b, a) converges absolutely for almost all (b, a)

∈ B × A and Rf ∈ L 1 (B × A). Indeed Rf L 1 (B×A,db da) ≤ |W | f 1 ; see [8], Lemma 3.2. By [15], Ch. II, Theorem 3.2, the Radon transform is injective on L 1 (X). Notice that if Rf ∈ L 1 (B × A) then for almost all a ∈ A we have Rf (•, a) ∈ L 1 (B).
The Helgason-Fourier transform of a sufficiently regular function f is the Euclidean Fourier transform of the Radon transform. For instance, if f ∈ L 1 (X), then

Ff (λ, b) = F A Rf (b, •) (λ) = A Rf (b, a)e -iλ(log a) da . ( 26
)
for almost all b ∈ B and all λ ∈ a * . See e.g. the proof of formula (43), Ch. III, §1 in [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF].

2.6. Analysis on B = K/M . Let K denote the set of (equivalence classes of) irreducible unitary representations of K. Fix δ ∈ K acting on the space V δ of finite dimension d(δ). We consider V δ endowed with an inner product •, • making δ unitary. Let M = Z K (A) be the centralizer of A in

K. A vector v ∈ V δ is said to be M -fixed if δ(m)v = v for all m ∈ M . Let V M δ denote the subspace of M -fixed vectors of V δ . We denote by K M the subset of K consisting of (equivalence classes of) representations of K for which dim V M δ > 0. As before, let B = K/M . For f : B → C sufficiently regular, we define f δ : B → Hom(V δ , V δ ) by f δ (kM ) = d(δ) K δ(k -1 1 )f (k 1 kM ) dk 1 , k ∈ K . ( 27
) Then f δ (kM ) = δ(k)f δ (eM ) (28)
for all k ∈ K. In particular, f δ = 0 for δ / ∈ K M . The functions f δ determine f ∈ L 2 (B) by the Peter-Weyl theorem for vector-valued functions, stating that

f = δ∈ K M Trace(f δ ) . (29)
See [START_REF] Helgason | Groups and geometric analysis. Integral geometry, invariant differential operators, and spherical functions[END_REF], Ch. V, Corollary 3.4. More generally, (29) holds in the sense of distributions when f ∈ L 1 (B). See [START_REF] Helgason | Groups and geometric analysis. Integral geometry, invariant differential operators, and spherical functions[END_REF], p. 508. Let v 1 , . . . , v d(δ) be an orthonormal basis of V δ . For i, j = 1, . . . , d(δ), define f δ i,j ∈ C by

f δ i,j = d(δ) -1 f δ (eM )v i , v j = K δ(k -1 )v i , v j f (kM ) dk . (30)
Observe that, by ( 28) and (30), we have f δ = 0 if and only if f δ i,j = 0 for all i, j = 1, . . . , d(δ). Moreover, by (29), f = 0 if and only if f δ = 0 for all δ ∈ K M .

The Euclidean case

3.1. The damped Schrödinger equation on R n . Let F R n denote the Fourier transform on R n . For a (sufficiently regular) function f on R n , we also write f = F R n f . We fix as a measure on R n the Lebesgue measure divided by the factor (2π) n/2 .

Consider the initial value problem for the time-dependent damped Schrödinger equation on R n :

i∂ t u(t, x) + (∆ -c)u(t, x) = 0 u(0, x) = f (x) (S c )
where ∆ denotes the Laplace operator on R n and c ∈ R is the damping parameter. Suppose

f ∈ L 2 (R n ). Then there is a unique u ∈ C(R : L 2 (R n )) satisfying (S c
) in the sense of distributions and such that u(0, •) = f . In fact, let |λ| denote the euclidean norm of λ ∈ R n . The Fourier transform F R n gives a unitary equivalence of ∆ with the multiplication operator

M on L 2 (R n ) defined by (M f )(λ) = -|λ| 2 f (λ). It follows that the unique solution u t (x) = u(t, x) of (S c ) is characterized by the equation u t (λ) = e -i(|λ| 2 +c)t f (λ) . (31)
Equivalently, u t = F -1 R n e -i(|λ| 2 +c)t F R n f . See for instance [START_REF] Rauch | Partial differential equations[END_REF], §3.5, Theorem 1 and Corollary 2. We will need precise information on the solution of (31) in the space S (R n ) of tempered distributions on R n for functions f which are not necessarily in L 2 (R n ).

Let O M (R n ) denote the space of functions ϕ on R n which are C ∞ with slow growth (i.e. each derivative of ϕ is bounded by a polynomial), and let O C (R n ) be the space of rapidly decreasing distributions T on R n (i.e. T ∈ S (R n ) and T * ϕ ∈ S(R n ) for all ϕ ∈ S(R n )). See [START_REF] Schwartz | Théorie des distributions[END_REF], p. 243-245. Then the Fourier transform is an isomorphism of

O M (R n ) onto O C (R n ). For every fixed a ∈ R, we have e -ia|x| 2 ∈ O M (R n ) ∩ O C (R n ). The following properties hold. Lemma 3.1. If S ∈ O M (R n ), T ∈ O C (R n ) and F ∈ S (R n ), then (a) SF ∈ S (R n ) and T * F ∈ S (R n ) . (b) SF = S * F and (T * F ) = T F .
Proof. See [START_REF] Schwartz | Théorie des distributions[END_REF], Ch. VII, §8, théorème XV.

Let c ∈ R and t = 0 be fixed. In S (R n ), we have, with our normalisation of the Lebesgue measure:

γ c,t (λ) = e -i(|λ| 2 +c)t if γ c,t (x) = (2|t|) -n/2 e -ict e -πi(sign t)n/4 e i |x| 2 4t
, where sign t := t/|t|. See for instance [START_REF] Hörmander | The analysis of linear partial differential operators[END_REF], Theorem 7.6.1. Thus part (b) in Lemma 3.1 gives for

F ∈ S (R n ) e -i(|λ| 2 +c)t F = γ c,t F = (γ c,t * F ) ∧ .
Since the Fourier transform is injective on S (R n ), we obtain that the unique solution to the equation

u t = e -i(|λ| 2 +c)t f in S (R n ) is u t = γ c,t * f . (32)
Applying this property to the damped Schrödinger equation, we obtain in particular that, if f ∈ L 1 (R n ), then for t = 0 the solution to (S c ) can be written explicitly as

u(t, x) = (γ c,t * f )(x) = (2π) n/2 (2|t|) -n/2 e -ict e -πi(sign t)n/4 e i |x| 2 4t h t x 2t (33)
where 33) and (34) hold as equalities in L 2 (R n ).

h t (y) = e i |y| 2 4t f (y) . ( 34
) If f ∈ L 2 (R n ), then (

3.2.

Beurling-type uncertainty principles in R n . Beurling's theorem, proven by Hörmander in [START_REF] Hörmander | A uniqueness theorem of Beurling for Fourier transform pairs[END_REF], provides one of the strongest quantitative versions of the uncertainty principles for the Fourier transform on R.

Theorem 3.2 (Beurling's theorem). Let f ∈ L 1 (R). If R R |f (x)|| f (y)|e |xy| dx dy < ∞ then f = 0 almost everywhere.
A simplified proof of Theorem 3.2 can be found in the appendix of [START_REF] Bonami | Hermite functions and uncertainty principles for the Fourier and the windowed Fourier transforms[END_REF]. Some higher dimensional versions of this theorem have been proven recently by Bagchi and Ray. One of these versions is the following theorem. See [START_REF] Bagchi | Uncertainty principles like Hardy's theorem on some Lie groups[END_REF], Corollary 1.

Theorem 3.3. Let f ∈ L 1 (R n ). Suppose that R n R n |f (x)|| f (y)|e |x||y| dx dy < ∞ .
Then f = 0 almost everywhere. Corollary 3.4. Suppose f, u t satisfy (31). If f ∈ L 1 (R n ) and there is t 0 > 0 so that

R n R n |f (x)||u(t 0 , y)|e |x||y| 2t 0 dx dy < ∞ (35) then f = 0. Hence u(t, •) = 0 for all t ∈ R.
Proof. According to (35) and (33), we have

+∞ > R n R n |f (x)||u(t 0 , y)|e |x||y| 2t 0 dx dy = 1 (2t 0 ) n/2 R n R n h t 0 (x) h t 0 y 2t 0 e |x||y| 2t 0 dx dy = (2t 0 ) n/2 R n R n |h t 0 (x)|| h t 0 (y)|e |x||y| dx dy
Theorem 3.3 gives then h t 0 = 0 and hence f = 0. Thus u(t, •) = 0 for all t ∈ R by (33).

Corollary 3.5. Let u(t, x) ∈ C(R : L 2 (R n )) be the solution to the initial value problem (S c ) with initial condition f ∈ L 2 (R n ). If there is t 0 > 0 so that (35) holds. Then f = 0 and hence u(t, •) = 0 for all t ∈ R.

Proof. By Corollary 3.4, it suffices to prove that f ∈ L 1 (R n ). If u(t 0 , •) = 0 a.e., then f = e i(|λ| 2 +c)t 0 u t 0 = 0. Hence f = 0. We can therefore suppose that u(t 0 , •) is not a.e. zero. By (35), we have

|u(t 0 , y)| R n |f (x)|e |x||y| 2t 0 dx < ∞ (36)
for almost all y ∈ R n . Since u t 0 does not vanish almost everywhere, (36) gives for some

y 0 ∈ R n R n |f (x)| dx ≤ R n |f (x)|e |x||y 0 | 2t 0 dx < ∞ . Thus f ∈ L 1 (R n ).
i∂ t u(t, x) + ∆u(t, x) = 0 u(0, x) = f (x) (S)
where ∆ is the Laplace-Beltrami operator on X. Suppose f ∈ L 2 (X). Then the analysis of solutions of the Schrödinger equation on R n carries out to X when the Fourier transform F R n is replaced by the Helgason-Fourier transform F. In fact, by [START_REF] Gangolli | Harmonic analysis of spherical functions on real reductive groups[END_REF], the function e λ,b appearing in the definition of the Helgason-Fourier transform are eigenfunctions of the Laplace-Beltrami operator ∆. Hence, by the Plancherel theorem, F is a unitary equivalence of ∆ with the multiplication operator M on

L 2 (a * × B, dλ db |c(λ)| 2 ) defined by (M f )(λ, b) = -(|λ| 2 + |ρ| 2 )f (λ, b).
It follows that there is a unique u t (x) = u(t, x) ∈ C(R : L 2 (X)) satisfying (S) in the sense of distributions on X and such that u(0, •) = f . It is characterized by the equation

(Fu t )(λ, b) = e -i(|λ| 2 +|ρ| 2 )t Ff (λ, b) . (37)
Equivalently, u t = F -1 e -i(|λ| 2 +|ρ| 2 )t Ff . We observe, in particular, that u ∈ C(R : S(X)) if f ∈ S(X). Here S(X) is the Schwartz space of smooth rapidly decreasing functions on X; see e.g. [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF], pp. 214-220. Notice that, as F is a bijection on L 2 (X), the condition f = 0 implies u t = 0 for all t ∈ R. Conversely, suppose there is t 0 ∈ R so that u t 0 = 0. Then (37) gives e -i(|λ| 2 +|ρ| 2 )t 0 Ff (λ, b) = 0 for all (λ, b). Hence Ff = 0. Thus f = 0 and u t = 0 for all t ∈ R. This remark applies more generally to solutions of (37) in S (X), the space of tempered distributions on X.

4.2.

The class of functions L 1 (X) C . Let Ξ and σ be the functions defined in ( 16) and ( 13), respectively. Let C ≥ 0. For a measurable function h : X → C we set

h 1,C := X |h(x)|Ξ(x)e Cσ(x) dx
We denote by L 1 (X) C the C-vector space of (equivalence classes of a.e. equal) functions on X for which h 1,C < ∞.

The motivation for introducing this class of functions is the following. Suppose f, u t 0 satisfy Beurling's condition [START_REF] Anker | A basic inequality for scattering theory on Riemannian symmetric spaces of the noncompact type[END_REF]. Then f ∈ L 1 (X) C for some C ≥ 0. Indeed if u(t 0 , •) vanishes almost everywhere, then f = 0 by (37); if u(t 0 , •) does not vanish almost everywhere, (1) implies

|u(t 0 , y)|Ξ(y) X |f (x)|Ξ(x)e σ(x)σ(y) 2t 0 dx dy < ∞
for almost all y ∈ X, whence the result with C = σ(y)/t 0 for any y = o such that u(t 0 , y) = 0. Likewise (1) implies u(t 0 , •) ∈ L 1 (X) C for some C > 0 and we may assume C = C .

Consequently, the Radon transform Rh of a function h ∈ L 1 (X) C is almost everywhere defined and Rh ∈ L 1 (B × A, e Cσ(a) da db).

Proof. Because of the definition of Ξ in ( 16), we have

X |h(x)|Ξ(x)e Cσ(x) dx = G K |h(g • o)|e -ρ(H(gk))
e Cσ(g) dg dk .

Then (38) follows by the right-K-invariance of σ and the map g → h(g • o). Suppose now that X |h(x)|Ξ(x)e Cσ(x) dx < ∞. By (38), the integral formula (8) for the Iwasawa decomposition and the inequality [START_REF] Helgason | Geometric analysis on symmetric spaces[END_REF], we can write this integral as The Radon transform Rh of a function h ∈ L 1 (X) C is well defined and Rh ∈ L 1 (B × A). In fact, we also have h ∈ L 1 (X) when C is sufficiently big. Lemma 4.2. For all x ∈ X, we have

Ξ(x)e |ρ|σ(x) ≥ 1 . (40)
Consequently, L 1 (X) C ⊂ L 1 (X) for C ≥ |ρ|.

Proof. By [START_REF] Rauch | Partial differential equations[END_REF], for all a = exp H ∈ A + we have Ξ(a • o)e |ρ|σ(a•o) ≥ Ξ(a • o)e ρ(H) ≥ 1. The inequality (40) then follows by K-invariance of Ξ and σ and by the decomposition G = KA + K.

Even if h ∈ L 1 (X) C may not be in L 1 (X) unless C is sufficiently big, we have Rh(b, •) ∈ L 1 (A) for almost all b ∈ B by Lemma 4.1. So we can consider F A Rh(b, •) . In fact, on L 1 (X) C the equality F = F A • R holds.
To prove this, we work on K-types. Let δ ∈ K M and let v 1 , . . . , v d(δ) be a fixed orthonormal basis of the space V δ of δ. Recall from (30) the notation f δ i,j for f : B = K/M → C. Recall also that f δ = 0 if and only if f δ i,j = 0 for all i, j = 1, . . . , d(δ). Lemma 4.3. Let C ≥ 0 be a constant and let h ∈ L 1 (X) C . For a ∈ A and λ ∈ a * set

(Rh) δ i,j (a) := ((Rh)(•, a)) δ i,j = K δ(k -1 )v i , v j Rh(kM, a) dk (41) (Fh) δ i,j (λ) := (Fh(λ, •)) δ i,j = K δ(k -1 )v i , v j Fh(λ, kM ) dk (42)
For a function g :

a * → C, set g ∞ := sup λ∈a * |g(λ)|. Then F A (Rh) δ i,j ∞ ≤ h 1,C (43)
(Fh) δ i,j ∞ ≤ h 1,C (44)
Suppose moreover that Rh ∈ L 1 (B × A) and set

F A (Rh) δ i,j (λ) := K δ(k -1 )v i , v j F A Rh(kM, •) (λ) dk . ( 45
)
Then F A (Rh) δ i,j = F A (Rh) δ i,j (46)
Proof. By (41) we have

F A (Rh) δ i,j (λ) = A K δ(k -1 )v i , v j Rh(kM, a)e iλ(log a) da dk . ( 47
)
Since δ is unitary and v 1 , . . . , v d(δ) is an orthonormal basis, we obtain from (39):

|F A (Rh) δ i,j (λ)| ≤ A B |Rh(b, a)| db da ≤ h 1,C .
This proves (43). To prove (44), we have by [START_REF] Sarkar | Beurling's theorem for Riemannian symmetric spaces[END_REF]: So (44) follows again from (39). Finally, ( 46) is a consequence of (47) and Fubini's theorem, which applies as Rh ∈ L 1 (B × A).

|Fh(λ, b)| ≤ A N |h(kan • o)|e ρ(log a) da dn
Corollary 4.4. Suppose h ∈ C ∞ c (X). Then for all i, j = 1, . . . , d(δ) and λ ∈ a * F A (Rh) δ i,j (λ) = (Fh) δ i,j (λ) . ( 48
) Proof. For h ∈ C ∞ c (X) we have F A • R = F. Proposition 4.5. Let C ≥ 0. Let δ ∈ K M and v 1 , . . . , v d(δ) be as above. Then for all h ∈ L 1 (X) C F A (Rh) δ i,j = F A (Rh) δ i,j = (Fh) δ i,j (49)
as functions on a * . Consequently,

F = F A • R on L 1 (X) C .
Proof. The first equality is a consequence of (46). For the second, let h ∈ L 1 (X) C , and let h n ∈ C ∞ c (X) be a sequence converging to h in L 1 (X) C . By (43), ( 44) and ( 46), for all i, j = 1, . . . , d(δ), the sequences [F A (Rh n )] δ i,j and (Fh n ) δ i,j converge in L ∞ (a * ) to [F A (Rh)] δ i,j and (Fh) δ i,j , respectively. But [F A (Rh n )] δ i,j = (Fh n ) δ i,j by Corollary 4.4. Hence [F A (Rh)] δ i,j = (Fh) δ i,j by uniqueness of the limit. Since this is true for all δ ∈ K M and every orthonormal basis v 1 , . . . , v d(δ) of the space of δ, we conclude that

F = F A • R on L 1 (X) C .
We conclude this section by a remark on the convolution h × ψ of two elements in L 1 (X) C under the additional assumption that ψ is K-invariant. Recall that the convolution of two sufficiently regular functions f 1 and f 2 on X is the function f 1 ×f 2 defined on X by (f

1 ×f 2 )•π = (f 1 •π) * (f 2 •π).
Here π : G → X = G/K is the natural projection and * denotes the convolution product of functions on G. This convolution is not commutative.

Proposition 4.6. Let C ≥ 0 and let h, ψ ∈ L 1 (X) C . Suppose that ψ is K-invariant. Then h × ψ ∈ L 1 (X) C . More precisely, we have X |(h × ψ)(x)|Ξ(x)e Cσ(x) dx ≤ h 1,C ψ 1,C .
. Recall that if u t = u(t, •) is a solution of (S) with initial condition f ∈ L 2 (X) satisfying X X |f (x)||u(t 0 , y)|Ξ(x)Ξ(y)e σ(x)σ(y) 2t 0 dx dy < +∞ (50)
for some t 0 > 0, then f, u t 0 ∈ L 1 (X) C for some constant C > 0.

Proof of Theorem 1.1. Observe that, by applying an argument similar to that in the proof of Lemma 4.1, we get

X X |f (x)||u(t 0 , y)|Ξ(x)Ξ(y)e σ(x)σ(y) 2t 0 dx dy = = G G |f (g 1 • o)||u(t 0 , g 2 • o)|e -ρ(H(g 1 )+H(g 2 )) e σ(g 1 )σ(g 2 ) 2t 0 dg 1 dg 2 . (51)
By (37), to prove that u(t, •) = 0 for all t ∈ R, it is enough to prove that f = 0. But by Proposition 4.5, we have Ff = F A (Rf ) as f ∈ L 1 (X) C for some C > 0. Since F is an isometry on L 2 (X), it therefore suffices to prove that Rf = 0. For this, we shall prove that (Rh) δ i,j = 0 for all δ ∈ K M and i, j = 1, . . . , d(δ). This would complete the proof by the comments at the end of section 2.6.

By proceeding as in the proof of (38), we have

X X |f (x)||u(t 0 , y)|Ξ(x)Ξ(y)e σ(x)σ(y) 2t 0 dx dy ≥ ≥ A B A B (R|f |)(b 1 , a 1 )(R|u t 0 |)(b 2 , a 2 )e | log a 1 || log a 2 | 2t 0 da 1 da 2 db 1 db 2 ≥ A A B |Rf (b 1 , a 1 )|db 1 B |Ru t 0 (b 2 , a 2 )|db 2 e | log a 1 || log a 2 | 2t 0 da 1 da 2 .
By (41), this implies that

A A |(Rf ) δ i,j (a 1 )||(Ru t 0 ) δ i,j (a 2 )|e | log a 1 || log a 2 | 2t 0 da 1 da 2 < ∞ (52)
for all δ ∈ K M and i, j = 1, . . . , d(δ).

On the other hand, (37) together with (49) gives us

F A (Ru t ) δ i,j (λ) = e -i(|λ| 2 +|ρ| 2 )t F A (Rf ) δ i,j (λ) . (53)
Now, by Corollary 3.4, we obtain (Rf ) δ i,j = 0 for all δ ∈ K M and i, j = 1, . . . , d(δ), concluding the result.

Remark 4.7. Note that (51) give us the Beurling's condition in group terms.

As an immediate corollary of Theorem 1.1, we obtain the following result for compactly supported initial conditions. Corollary 4.8. Let u(t, x) ∈ C(R : L 2 (X)) denote the solution of (S) with initial condition f ∈ L 2 (X). Suppose that f has compact support. If there is a time t 0 > 0 so that u(t 0 , •) has compact support. Then f = 0 and hence u(t, •) = 0 for all t ∈ R.

Proof. It suffices to observe that (1) is always satisfied if f and u(t 0 , •) are compactly supported. Remark 4.9. For f ∈ L 2 (X) the Radon transform Rf (b, •) as well as the K-types (Rf ) δ i,j appearing in (53) need not be in L 2 (A). This can be easily seen for functions f satisfying Ff = F A (Rf ). Indeed the Euclidean Fourier transform is an isometric isomorphism of L 2 (A) onto L 2 (a * ). According to the Plancherel theorem, the image of L 2 (X) under the Helgason-Fourier transform is

L 2 (a * + × B, |c(λ)| -2 dλ db). So Rf (b, •) ∈ L 2 (A) for almost all b ∈ B provided L 2 (a * , |c(λ)| -2 dλ) ⊂ L 2 (
a * , dλ). The latter condition depends on the Harish-Chandra's c-function appearing in the Plancherel measure. Using the properties of the gamma function, one can prove the asymptotic behaviour

1 |c(λ)| 2 α∈Σ + 0 | λ, α | 2 α∈Σ + 0 (1 + | λ, α |) mα+m 2α -2 . ( 54
)
See e.g. [START_REF] Anker | A basic inequality for scattering theory on Riemannian symmetric spaces of the noncompact type[END_REF], Lemma 1. Here f g means that there exists positive constants C 1 and C 2 so that C 1 g(λ) ≤ f (λ) ≤ C 2 g(λ) for all λ.

In the rank-one case, we have for instance the following result. The boundedness of Ff (b, •) at λ = 0 for almost all b ∈ B is obtained under very weak assumptions on f . Recall for instance that for almost all b ∈ B, the function Ff (b, •) is even holomorphic in a tube around a * . See section 2.5. Moreover, in this case Ff (b, •) vanishes at infinity by Fatou's lemma for F. We can then prove that Rf ∈ L 2 (A) for f ∈ L 1 (X) ∩ L 2 (X) whenever the root system satisfies the following conditions:

(C) Either there is no α ∈ Σ + 0 with multiplicity m α = 1, or 2α ∈ Σ + . When condition (C) is met, then we have

α∈Σ + 0 (1 + | λ, α |) mα+m 2α -2 ≥ C (55)
for all λ ∈ a * . The result Rf ∈ L 2 (A) for f ∈ L 2 (X) ∩ L 1 (X) is then a consequence of the above discussion and the following lemma.

Lemma 4.11. Let Σ be a root system satisfying condition (C). Suppose h ∈ L 2 (a * , |c(λ)| -2 dλ) is continuous and vanishes at infinity. Then h ∈ L 2 (a * , dλ).

Proof. Set Π(λ) = α∈Σ + 0 λ, α . By Lemma 5 in [START_REF] Anker | A basic inequality for scattering theory on Riemannian symmetric spaces of the noncompact type[END_REF], the set

Ω 1 = {λ ∈ a * : |Π(λ)| ≤ 1} has finite Lebesgue measure. Let B 1 = {λ ∈ a * : λ ≤ 1} and C 1 = a * \ B 1 . Write a * |h(λ)| 2 dλ = B 1 |h(λ)| 2 dλ + Ω 1 ∩C 1 |h(λ)| 2 dλ + (a * \Ω 1 )∩C 1 |h(λ)| 2 dλ .
The first integral is finite as h is continuous, hence bounded on the compact B 1 . The second integral is also finite as h is continuous and vanishes at infinity, so it is bounded in C 1 , and Ω 1 ∩ C 1 is a subset of Ω 1 , hence of finite measure. For the convergence of the third integral, we use condition (C). In fact, condition (C) yields (55). Moreover, on a * \Ω 1 , we have

|Π(λ)| ≥ 1. Thus |c(λ)| -2 ≥ C for all λ ∈ (a * \ Ω 1 ) ∩ C 1 . Consequently, (a * \Ω 1 )∩C 1 |h(λ)| 2 dλ ≤ C -1 (a * \Ω 1 )∩C 1 |h(λ)| 2 dλ |c(λ)| 2 < +∞.

Applications

Let X be a Riemannian symmetric space of the noncompact type. In this section we collect some uniqueness conditions for the solution of the Schrödinger equation (S) on X which can be deduced from Theorem 1.1. They correspond to uncertainty principle conditions of Gelfand-Shilov type, Cowling-Price type and Hardy type. These results are parallel to the classical results of uncertainty principles for the Fourier transform on R n . Recall from (17) that 0 < Ξ(x) ≤ 1 for all x ∈ X. Theorem 5.1 (Gelfand-Shilov type). Let u(t, x) ∈ C(R : L 2 (X)) be the solution of (S) with initial condition f ∈ L 2 (X). Suppose there exists positive constants α, β and a time t 0 > 0 so that

X |f (x)|Ξ(x)e α p p σ p (x) dx < ∞ and X |u(t 0 , x)|Ξ(x)e β q q σ q (x) dx < ∞ (56)
where 1 < p < ∞ and 1 p + 1 q = 1 . If 2t 0 αβ ≥ 1, then f = 0 and hence u(t, •) = 0 for all t ∈ R.

Proof. We have σ(x)σ(y) 2t 0 ≤ αβσ(x)σ(y) ≤ α p p σ p (x) + β q q σ q (y). The inequalities (56) imply then Beurling's condition (1). Theorem 5.2 (Cowling-Price type). Let u(t, x) ∈ C(R : L 2 (X)) be the solution of (S) with initial condition f ∈ L 2 (X). Suppose there exists positive constants a, b and a time t 0 > 0 so that

X |f (x)|e aσ 2 (x) p dx < ∞ and X |u(t 0 , x)|e bσ 2 (x) q dx < ∞ (57)
where 1 ≤ p, q ≤ ∞. If 16t 2 0 ab > 1, then f = 0 and hence u(t, •) = 0 for all t ∈ R.

Proof. Choose A, B so that 0 < A < a, 0 < B < b and 16t 2 0 AB > 1. Let p and q so that x) . Observe that, by ( 9) and ( 10), the function e η ∈ L p (X) for

1 p + 1 p = 1 and 1 q + 1 q = 1. Set e η (x) = e ησ 2 (
all p ∈ [1, +∞] if η < 0. Indeed, by K-invariance of σ, X |e η (x)| p dx ≤ c a + e pη|H| 2 δ(H) dH ≤ c a + e pη|H| 2 +2ρ(H) dH < ∞ .
By [START_REF] Hörmander | The analysis of linear partial differential operators[END_REF], Hölder inequality and the assumption,

f Ξe A 1 ≤ f e A 1 ≤ f e a p e (A-a) p < ∞ , u(t 0 , •)Ξe B 1 ≤ u(t 0 , •)e B 1 ≤ u(t 0 , •)e b q e (B-b) q < ∞ .
The stated result is then a consequence of Theorem 5.1 with p = q = 2, A = α 2 /2 and B = β 2 /2.

Remark 5.3. Let ψ be a function on X satisfying ψ(x)e νσ 2 (x) ∈ L ∞ (X) and ψ(x) -1 e νσ 2 (x) ∈ L ∞ (X) for all ν < 0. Because of the strict inequality 16t 2 0 ab > 1 in Theorem 5.2, we can replace the functions e ησ 2 (x) , with η ∈ {a, b}, measuring the growth of f and u t 0 , respectively, with ψ(x)e ησ 2 (x) . For instance, we can choose ψ(x) = Ξ(x) M (1 + σ(x)) N for some fixed integers M and N . Similar remarks apply to Corollary 5.4 and Theorem 5.5 below.

Corollary 5.4. Let u(t, x) ∈ C(R : L 2 (X)) be the solution of (S) with initial condition f ∈ L 2 (X). Suppose there exists positive constants a, A, b, B and a time t 0 > 0 so that for all x ∈ X |f (x)| ≤ A e -a p p σ p (x) and |u(t 0 , x)| ≤ B e -b q q σ q (x)

where 1 < p < ∞ and 1 p + 1 q = 1 . If 2t 0 ab > 1, then f = 0 and hence u(t, •) = 0 for all t ∈ R.

Proof. Choose α, β so that 0 < α < a, 0 < β < b and 2t 0 αβ > 1. Then f and u(t 0 , •) satisfy (56).

Theorem 5.5 (Hardy type). Let f be a measurable function on X so that there exists positive constants A and α so that |f (x)| ≤ A e -ασ 2 (x) (59) for all x ∈ X. Then f ∈ L 2 (X). Let u(t, x) ∈ C(R : L 2 (X)) be the solution of (S) with initial condition f . Suppose, moreover, that there is a time t 0 > 0 and positive constants B and β so that

|u(t 0 , x)| ≤ B e -βσ 2 (x) (60)
If 16αβt 2 0 > 1, then u(t, •) = 0 for all t ∈ R. Proof. By the K-binvariance of σ and the integral formula ( 9) and ( 10), the growth condition on f implies

X |f (x)| 2 dx ≤ A 2 X e -2ασ 2 (x) dx ≤ cA 2 a + e -2α|H| 2 δ(H) dH ≤ cA 2 a + e -2α|H| 2 +2ρ(H) dH < ∞ . If 16αβt 2 0 > 1, then u(t,
•) ≡ 0 for all t ∈ R. Suppose now that G has a complex structure and f is a K-invariant function on X. A Kinvariant function on X can be identified with a W -invariant function on A = exp a ≡ a. Here, as before, W denotes the Weyl group. In this identification, the space of K-invariant functions in L 2 (X) corresponds to the space of W -invariants in L 2 (a, η 2 (H) dH), where

η(H) = γ∈Σ + sinh γ(H) , H ∈ a . (64)
Moreover, the radial component on

A + ≡ a + of the Laplace-Beltrami operator ∆ on X is 1 η(H) ∆ a -|ρ| 2 • η(H) (65)
where ∆ a is the Laplace operator on a. If n = dim a and {H j } n j=1 is an orthonormal basis of a with respect to the inner product induced by the Killing form, then ∆ a = n j=1 ∂(H j ) 2 . Because of (65), u t = u(t, •) is the solution to (S) with K-invariant initial condition f ∈ L 2 (X) if and only if η(H)u t (H) is the solution of the damped Schrödinger equation (S c ) on a ≡ R n with damping parameter c = |ρ| 2 and W -skew-invariant initial condition η(H)f (H).

When G admits a complex structure, all root multiplicities m γ are equal to 2. Writing ψ(H) instead of ψ(exp H), we therefore have

ψ(H) = π(H) η(H) , H ∈ a , where π(H) = γ∈Σ + γ(H) .
Let α, β be two positive constants and let

f (x) = ψ(x)e -ασ 2 (x) e -i √ αβσ 2 (x) , x ∈ X .
Then f is a K-biinvariant function in L 2 (X). Considered as a function on A ≡ a, we have f (H) = π(H) η(H) e -α|H| 2 e -i √ αβ|H| 2 , H ∈ a .

Let u(t, x) be the solution of (S) with initial condition f . Then η(H)u(t, H) , H ∈ a, is the solution of (S c ) with damping parameter |ρ| 2 and initial condition η(H)f (H). Set t 0 = (16αβ) for all H ∈ a, i.e. u(t 0 , x) = c t 0 ψ(x)e -βσ 2 (x) e i σ 2 (x) 4t 0 for all x ∈ X. Since f and u t respectively satisfy the estimates (62) and (63), the uniqueness property in Corollary 5.7 fails when 16t 2 0 αβ = 1. In fact, we shall prove in Theorem 5.9 below that the function f we just considered is (up to constant multiples) the only function which can occur in the case 16t 2 0 αβ = 1. We shall derive this property from the following equality case of Hardy's theorem on R n ; see [START_REF] Thangavelu | An introduction to the uncertainty principle. Hardy's theorem on Lie groups[END_REF], Theorem 1.4.4. with a, b > 0. When ab = 1 4 , then h(x) = P (x)e -a|x| 2 where P is a polynomial of degree ≤ 2m. Theorem 5.9. Let X = G/K be a Riemannian symmetric space with G complex. Suppose f is a K-invariant function on X satisfying (62). Let u(t, •) be the solution of (S) with initial condition f . Assume that u(t 0 , x) satisfies (63). If 16αβt 2 0 = 1, then there exists a constant C so that f (x) = C ψ(x)e -ασ 2 (x) e -i √ αβσ 2 (x) . for all x ∈ X.

Proof. It remains to prove that if f and u t 0 satisfy (62) and (63), respectively, then f (x) is a constant multiple of ψ(x)e -ασ 2 (x) e -i √ αβσ 2 (x) . We know that η(H)u t (H) is the solution of the damped Schrödinger equation on a with damping parameter |ρ| 2 and initial condition η(H)f (H) ∈ L 2 (a, dH). Hence, by (33) ) m and α(4t 2 0 β) = 1/4, we obtain from Lemma 5.8 that h t 0 (H) = P (H)e -α|H| 2 where P (H) is a polynomial of degree ≤ 2m. Therefore e i |H| 2 4t 0 η(H)f (H) = P (H)e -α|H| 2 . This equality shows that P (H) must be Wskew-invariant, so divisible by π(H). Hence P (H) = q(H)π(H) for a W -invariant polynomial q(H) so that deg q = deg P -deg π ≤ 2m -|Σ + | ≤ 1. This is only possible when q(H) = C is a constant.

Thus f (H) = C π(H) η(H) e -i |H| 2
4t 0 e -α|H| 2 , which proves the claim.

4 . 4 . 1 .

 441 The case of a Riemannian symmetric space of the noncompact type The Schrödinger equation on X. Consider the initial value problem for the time-dependent Schrödinger equation on the Riemannian symmetric space X = G/K:

Lemma 4 . 1 .(

 41 Let h be a measurable function on X and let C ≥ 0 be a constant. Then X |h(x)|Ξ(x)e Cσ(x) dx = G |h(g • o)|e -ρ(H(g)) e Cσ(g) dg . R|h|)(b, a)e Cσ(a) da db ≤ h 1,C .

  K×A×N |h(kan • o)|e -ρ(log a) e Cσ(an) e 2ρ(log a) dk da dn ≥ K A e ρ(log a) N |h(kan • o)| dn e Cσ(a) da dk = B A (R|h|)(b, a)e Cσ(a) da db . This proves (39). The final property then follows as |Rh(a, b)| ≤ e ρ(log a) N |h(kan • o)| dn = R|h|(a, b) .

(

  R|h|)(b, a) da db .

Proof.

  In the following we shall employ the same symbol to denote a function on X and the corresponding K-invariant function on G. By definition of convolution products on G, G (|h| * |ψ|)(g)Ξ(g)e Cσ(g) dg = G G |h(g)||ψ(g )|Ξ(gg )e Cσ(gg ) dg dg ≤ G |h(g)||ψ(g )|Ξ(gg )e Cσ(g) e Cσ(g ) dg dg since σ(gg ) ≤ σ(g) + σ(g ) and C ≥ 0. Replacing g by kg , k ∈ K, and using the K-invariance of ψ and σ, the latter integral becomes G G |h(g)||ψ(g )|Ξ(gkg )e Cσ(g) e Cσ(g ) dg dg , which does not depend on k. Integration over K leads to G G |h(g)||ψ(g )|Ξ(g)Ξ(g )e Cσ(g) e Cσ(g ) dg dg = h 1,C ψ 1,C in view of the classical functional equation of spherical functions. 4.3. The Beurling-type condition for the Schrödinger equation on X. In this section, we shall prove Theorem 1.1

Lemma 4 . 10 .

 410 Suppose dim a * = 1. Let h ∈ L 2 (a * , |c(λ)| -2 dλ) be bounded on {λ ∈ a * : |λ| ≤ r} for some r > 0. Then h ∈ L 2 (a * , dλ).Proof. The asymptotic formula (54) gives in this case:|c(λ)| -2 ≥ C for |λ| ≥ r. If h ∈ L 2 (a * , |c(λ)| -2 dλ),then h is square integrable with respect to the Lebesgue measure on {λ ∈ a * : |λ| ≥ r}. Hence h ∈ L 2 (a * , dλ), as it is bounded on the compact set {λ ∈ a * : |λ| ≤ r}.

Lemma 5 . 8 .

 58 Suppose h is a measurable function on R n that satisfies the estimates|h(x)| ≤ C(1 + |x| 2 ) m e -a|x| 2 and | h(ξ)| ≤ C(1 + |ξ| 2 ) m e -b|ξ| 2

  -1/2 . By (33) and (34) we have for a constant C 1 depending on t 0η(H)u(t 0 , H) = C 1 e (Y ) = π(Y )e -α|Y | 2 . Since h t 0 (H) = π(i∂) e -α|Y | 2 ∧ = C 2 π(i∂)e -|H| 2Observe that P (H)e -β|H| 2 is a constant multiple of e η(H)u(t 0 , H). Since η(H) is W -skew-invariant, so is P (H). Hence π(H) divides P (H). Thus P (H) = cπ(H) for a constant c. Therefore u(t 0 , H) = c t 0 π(H) η(H) e -β|H| 2 e

	-i	|H| 2 4t 0 i	|H| 2 4t 0
			i	|H| 2 4t 0 h t 0	H 2t 0
	where
	h t 0 4α
	and 16t 2 0 α = β -1 , we conclude that
	η(H)u(t 0 , H) = C 3 e i	|H| 2 4t 0 π(i∂)e -β|H| 2

where C 3 is a constant depending on t 0 . Moreover, π(i∂) = γ∈Σ + i∂(H γ ), where H γ is the unique element in a so that γ(H) = H γ , H for all H ∈ a. Since ∂(H γ )e -β|H| 2 = -2βγ(H)e -β|H| 2 , we have π(i∂)e -β|H| 2 = P (H)e -β|H| 2 where P (H) is a polynomial of degree deg P = deg π.

  , η(H)u(t 0 , H) = (γ |ρ| 2 ,t 0 * η • f )(H) = C t 0 e A|π(H)|e -α|H| 2 and h t 0 H 2t 0 = C -1 t 0 |π(H)ψ(H) -1 u(t 0 , H)| ≤ BC -1 t 0 |π(H)|e -β|H| 2 . So | h t 0 (ξ)| ≤ C t 0 |π(ξ)|e -4t2 0 β|ξ| 2 . Let m be the smallest integer such that 2m ≥ |Σ + |. Since |π(H)| ≤ C(1+|H|

			i	|H| 2 4t 0 h t 0	H 2t 0
	where	h t 0 (H) = e i	|H| 2 4t 0 η(H)f (H) .
	Hence
	|h t

0 (H)| = |η(H)f (H)| = |π(H)ψ(H) -1 f (H)| ≤

  2

Acknowledgements: This paper was partly written when the authors were visiting the Scuola Normale Superiore di Pisa and the Department of Mathematics of the IISc Bangalore. The authors would like to express their gratitude to Micheal Cowling and Fulvio Ricci for the invitation to the Intensive Research Period "Euclidean Harmonic Analysis, Nilpotent Lie Groups and PDEs" and to the Centro di Ricerca Matematica Ennio de Giorgi for financial support. They also thank E.K. Narayanan, A. Sitaram and S. Thangavelu for their hospitality and financial support. The second named author also acknowlegdes financial support from the Chennai Mathematical Institute; the first named author would like to thank the Indo-French Institute for Mathematics for travel support. Finally, we would like to express our thanks to S. Chanillo, P. Ciatti, M. Cowling, N. Lohoué, E.K. Narayanan and F. Ricci for discussions on the subject of this paper. We would also

Thus f ∈ L 2 (X). The uniqueness property is a consequence of Corollary 5.4 with p = q = 2 and α = a 2 /2, β = b 2 /2. Remark 5.6. Under the additional assumptions that f is K-invariant and G is endowed with a complex structure, Theorem 5.5 was proven in [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF] using the explicit expression of the elementary spherical functions. In fact, the Euclidean reduction via Radon transform provides an elementary proof of Theorem 5.5 for arbitrary X and f . Observe first that if h is a measurable function on X and there is C > 0 for which |h(x)| ≤ A e -Cσ 2 (x) for all x ∈ X, then h ∈ L 1 (X) ∩ L 2 (X). Suppose now that f and u t 0 satisfy (59) and (60), respectively. Choose a, b so that 0 < a < α, 0 < b < β and 16abt 2 0 > 1. By Proposition 1 in [START_REF] Sengupta | An analogue of Hardy's theorem for semi-simple Lie groups[END_REF], there are constants A , B > 0 so that for all (H, x) ∈ a × B we have |Rf (x, exp H)| ≤ A e -a|H| 2 and |Ru t 0 (x, exp H)| ≤ B e -b|H| 2 . By (37) and the fact that

) and damping parameter |ρ| 2 . The Hardy type uniqueness theorem for the Schrödinger equation on R n (Theorem 2 in [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF]) yields then Rf (x, •) = 0 for all x ∈ B. Since R is injective on L 1 (X), we conclude that f = 0 and hence u(t, •) = 0 for all t ∈ R.

In [START_REF] Chanillo | Uniqueness of solutions to Schrödinger equations on complex semi-simple Lie groups[END_REF], the value t 0 given in Theorem 5.5 by the inequality 16αβt 2 0 > 1 was proven to be optimal. Indeed, for the symmetric space X = SL(2, C)/SU (2), Chanillo gave the following example. Let f be the function on X which agrees on the maximally flat geodesic submanifold A ≡ R with the function e -x 2 -ix 2 /4 . Then f satisfies (59) with α = 1. The solution u(t, •) of the Schrödinger equation (S) with initial condition f is not identically zero even if it satisfies (60) for β = 1/16 at t 0 = (16αβ) -1/2 = 1. Thus the uniqueness property fails in this case for some α, β and t 0 with 16αβt 2 0 = 1. In the rest of this section we provide additional information on the optimality of t 0 . We consider some Hardy type uniqueness conditions which are slightly more restrictive than those stated in Theorem 5.5. So they still imply that the solutions of (S) are identically zero provided the condition 16αβt 2 0 > 1 holds. We then characterize the non-unique solutions in the case t 0 = (16αβ) -1/2 under the additional assumption that G is endowed with a complex structure and the initial condition f is K-invariant.

Observe first that we can modify the right-hand side of the estimates in Theorem 5.5 by a suitable positive bounded factor ψ without loosing the uniqueness property when 16αβt 2 0 > 1. We choose here ψ to be the function used by Harish-Chandra to control the decay of the elements in the Kbiinvariant L 2 -Schwartz space on G. See for instance [START_REF] Gangolli | Harmonic analysis of spherical functions on real reductive groups[END_REF], p. 256. Considered as a K-biinvariant function on G, the function ψ is uniquely defined on G by the condition

Then ψ is a positive K-invariant function on X which is bounded. More precisely, one can prove that for suitable positive constants c 1 , c 2 and nonnegative integers d 1 , d 2 one has

for all x ∈ X. The following result is then a consequence of Theorem 5.5.

Corollary 5.7. Let f be a measurable function on X and assume there exist positive constants A and α so that |f (x)| ≤ A ψ(x)e -ασ 2 (x) (62) for all x ∈ X. Then f ∈ L 2 (X). Let u(t, x) ∈ C(R : L 2 (X)) be the solution of (S) with initial condition f . Suppose, moreover, that there is a time t 0 > 0 and positive constants B and β so that |u(t 0 , x)| ≤ B ψ(x)e -βσ 2 (x) .

(63)