# Qiskit HumanEval: An Evaluation Benchmark For Quantum Code Generative Models

Sanjay Vishwakarma3, Francis Harkins3, Siddharth Golecha4, Vishal
Sharathchandra Bajpe3,
Nicolas Dupuis1, Luca Buratti2, David Kremer3, Ismael Faro3, Ruchir Puri1 and
Juan Cruz-Benito3  1IBM Research, Yorktown Heights, NY, USA  2IBM Research,
Zurich, Rüschlikon, Switzerland  3IBM Quantum, Yorktown Heights, NY, USA  4IBM
Quantum, Gurugram, Haryana, India

###### Abstract

Quantum programs are typically developed using quantum Software Development
Kits (SDKs). The rapid advancement of quantum computing necessitates new tools
to streamline this development process, and one such tool could be Generative
Artificial intelligence (GenAI). In this study, we introduce and use the
Qiskit HumanEval dataset, a hand-curated collection of tasks designed to
benchmark the ability of Large Language Models (LLMs) to produce quantum code
using Qiskit – a quantum SDK. This dataset consists of more than 100 quantum
computing tasks, each accompanied by a prompt, a canonical solution, a
comprehensive test case, and a difficulty scale to evaluate the correctness of
the generated solutions. We systematically assess the performance of a set of
LLMs against the Qiskit HumanEval dataset’s tasks and focus on the models
ability in producing executable quantum code. Our findings not only
demonstrate the feasibility of using LLMs for generating quantum code but also
establish a new benchmark for ongoing advancements in the field and encourage
further exploration and development of GenAI-driven tools for quantum code
generation.

###### Index Terms:

Qiskit, Large Language Models, Evaluation benchmarks, Qiskit HumanEval,
HumanEval

##  I Introduction

Quantum computing holds the promise of significantly advancing our
computational capabilities with its potential to offer considerable speed-ups
over classical computing in certain classes of problems. However, the problem
of creating efficient quantum code remains a challenging task, one requiring
expertise and specialization in both quantum information and software
engineering skills. To overcome these challenges, there is a growing interest
in leveraging Generative Artificial Intelligence (GenAI) technologies to
assist in the creation and optimization of quantum code [1, 2, 3].

Python has emerged as a leading language in the quantum computing space mainly
because of its simplicity, flexibility and broad support by powerful libraries
and frameworks [4]. Quantum software frameworks based on Python, such as
Qiskit [5, 6], play a crucial role in the computing ecosystem by providing
tools that facilitate design, simulation, and execution of quantum workloads.
These libraries significantly simplify the implementation of quantum
algorithms. However, these libraries have varied feature sets and
capabilities, and efficiently coding quantum algorithms remains a challenge.

In this context, GenAI emerges as a promising technology for enhancing the
quantum programming process. This approach not only has the potential to speed
up and streamline the developmental cycle of quantum software, but also opens
the door to potential novel quantum code realizations that might not be
intuitive by conventional programming methodologies. AI-mediated quantum code
generation can also simplify the quantum software development lifecycle and
make quantum computing more accessible to a broader range of users.

Qiskit [5] is an open-source quantum computing software development framework
provided by IBM. It enables users to program, simulate, and run quantum
algorithms on quantum computers. Qiskit offers a comprehensive suite of tools
for quantum circuit design, optimization, and execution, making it a versatile
platform for both researchers and practitioners in the field of quantum
computing. For executing quantum workloads, Qiskit Runtime is a key component
within the Qiskit ecosystem specifically designed to enhance the execution
efficiency of quantum workloads. It operates both as a service and a
programming model that facilitates the building, optimizing, and executing of
quantum workloads. This component significantly reduces the overhead
associated with setting up and running quantum computations by streamlining
the process from development to deployment. It allows users to execute quantum
circuits on quantum hardware or simulators with reduced latency and increased
throughput. It employs the quantum primitives model for construction and
execution of quantum workloads. Quantum primitives provide a simplified and
efficient approach to programming execution on quantum systems. These core
functions are designed to streamline the use of quantum hardware by
abstracting routine operations and optimizing execution strategies. Qiskit
Runtime facilitates easier access to quantum hardware by managing and
optimizing the orchestration of tasks and resource allocation, thereby
simplifying the integration of quantum capabilities into conventional
computational workflows.

This integration of Qiskit and tools like Qiskit Runtime within the dataset
ensures that the tasks are grounded in realistic and practical quantum
computing scenarios, enhancing the relevance and applicability of research
outcomes derived from the dataset.

This paper explores the cutting-edge intersection of GenAI for quantum code
generation, specifically in the context of evaluating the capabilities of
Large Language Models (LLMs) in generating code for Qiskit SDK. The assessment
code presents several challenges [7, 8] for LLMs, including evaluating the
quality of the generated code, ensuring syntactical correctness, and verifying
the accuracy of the code produced. In this paper, we introduce Qiskit
HumanEval (QHE), a variation of the HumanEval benchmark [8] tailored
specifically for quantum computing programming using Qiskit. This benchmark is
designed to assess the performance, quality, and knowledge of code generation
models in a variety of quantum tasks. These tasks, packaged as an evaluation
dataset of prompts, unit tests, and their canonical solutions, are designed to
assess the functional correctness of the generated quantum code. To the best
of our knowledge, despite some existing publications on using LLMs for quantum
computing [9, 2, 3], there is no research work evaluating the performance of
the quantum code generated by LLMs.

The paper is organized as follows: Section II presents the related work in the
area of evaluating code LLMs. Section III presents a summary of the Qiskit
HumanEval (QHE) dataset, including descriptions of various prompts, unit
tests, and tasks included. Section IV presents the results obtained after
evaluating several code LLMs using the QHE evaluation dataset. Section V
discusses the subject, presents some conclusions and future directions for
this work.

##  II Related work

There exist various code benchmarks for code LLMs evaluating the performance
in code completion [10, 11, 12], code repair and editing [13, 14], code
reasoning [15] or code understanding. Evaluating the quality of generated code
is different than natural language because code can be executed. For that
reason, the most popular benchmarks provide unit-tests that can be run so that
models can be evaluated on pass rate. Thus, it is less subjective than natural
language benchmarks which often rely on heuristics such as BLEU or ROUGE.
HumanEval [8] and MBPP [16], as well as their improved version EvalPlus [7],
are the most known benchmarks for code generation and program synthesis. They
aim to test language comprehension, python coding skills, and algorithms at
the level of an average entry-level programmer. These benchmarks are
structured very similarly, with minor differences in how the prompt is
formulated for the model: every test case contains an instruction that can be
implemented with a stand-alone function, a set of unit tests, and a canonical
solution that passes all the unit tests. These benchmarks are manually curated
to avoid any possible data leakage. Another relevant benchmark for code
generation is DS-1000 [17] which is aligned with real-world problems in data-
science using popular Python SDKs such as NumPy, Scikit-learn, TensorFlow or
Pytorch. Our dataset, which is described in the next section, is close to
DS-1000, also providing data science problems on the very popular Python
library Qiskit [4].

##  III Dataset description

The Qiskit HumanEval dataset is designed for an automated evaluation system.
All tests are written by humans, and are designed to assess the LLM in
producing executable and functionally accurate Qiskit code.

It facilitates a comprehensive evaluation of model proficiency in various
aspects of quantum programming, from basic circuit design to the
implementation of complex quantum algorithms. The dataset is inspired and
based on specifications similar to the HumanEval Dataset [18] but is tailored
specifically for the Qiskit SDK and contextualized for quantum computing
workloads.

The creation of this dataset is the result of a collaborative effort by a
panel of experts in quantum computing and Qiskit. The panel includes Qiskit
advocates, members of the Qiskit community, members of IBM Quantum support and
documentation, and quantum computing software developers. To ensure accuracy,
each team member defined a number of tasks, which were then peer-reviewed by
the other panel members. Each task and its components (such as prompts and
tests) were reviewed at least once by every member of the panel of experts.
Based on the feedback received, tasks were revised and improved until the
panel reached a consensus that they were correct in terms of definition,
feasibility, clarity, and reproducibility.

TABLE I: Task Categorization in the Qiskit Human Eval Dataset Category |  Number of Tasks
---|---
Quantum Circuit Generation |  $28$
Simulation and Execution |  $19$
State Preparation and Analysis |  $7$
Algorithm Implementation |  $14$
Gate Operations and Manipulation |  $17$
Visualization and Post-Processing |  $6$
Advanced Circuit Manipulation |  $8$
Quantum Circuit Serialization |  $2$

###  III-A Composition and Structure

The Qiskit HumanEval dataset incudes 101 distinct tasks, organized into eight
categories based on the quantum computing functionalities they test. Each test
is structured to simulate real-world quantum computing scenarios. These tasks
are categorized into several thematic areas, reflecting different facets of
quantum computing: This dataset provides a comprehensive array of tasks that
encompass a wide range of quantum computing functionalities, from basic
circuit construction to advanced algorithm simulations. It aims to challenge
and evaluate LLM models on their ability to generate syntactically correct and
functionally effective quantum code in diverse cases across quantum computing.
All tasks included in the dataset are original and not extracted from any
existing tutorials, courses, books, or papers. While the experts responsible
for creating the tasks may have been inspired by existing materials, they were
required to write each task from scratch. The dataset is not part of the
training dataset for the large language models (LLMs) being tested.
Additionally, this is reflected in certain tasks where the LLMs are required
to work with novel features for which there is even more limited
documentation.

The dataset includes an extensive set of problems, each formulated to test
different aspects of quantum programming:

####  III-A1 Quantum Circuit Generation

This category includes tasks involving the design and creation of quantum
circuits. It emphasizes the use of Qiskit’s classes and modules to construct
diverse quantum circuits, which serve as fundamental building blocks for
executing various quantum algorithms. Each circuit contains a series of
quantum gates arranged to perform specific computational tasks. Parametrized
and customized instruction sets are also tested here, allowing a variety of
circuits to represent different computational needs or hardware constraints,
thus enhancing the datasets diversity and applicability. It tests the model’s
ability to manipulate quantum circuits or construct circuits that meet
specific operational criteria.

####  III-A2 Simulation and Execution

Tasks in this category require models to execute quantum circuits on
simulators or actual quantum hardware using Qiskits interfaces. This includes
running simulations on different quantum simulators (Aer, Statevector), real
quantum system execution runs, analyzing results, and evaluating specific
properties like expectation values. This process tests the circuits under
idealized conditions as well as in environments that simulate real quantum
noise, providing insights into their performance and robustness. Additionally,
real-world execution on quantum hardware, such as IBM’s quantum processors, is
covered to evaluate the practical deployment and scalability of quantum
solutions.

####  III-A3 State Preparation and Analysis

This involves tasks focused on preparing specific quantum states and analyzing
their properties or dynamics, which is focused on examples based on
initialization and detailed examination of quantum states. This category is
fundamental for setting the stage for algorithm execution in a quantum
workflow. It involves preparing quantum states that are crucial for the proper
initiation of computational algorithms and analyzing these states to ensure
they meet the requisite criteria for successful algorithm implementation.

####  III-A4 Algorithm Implementation

This category details the implementation of a suite of quantum algorithms
represented in the dataset. It includes contextualized quantum circuit
generation that set the groundwork for algorithm initialization, and oracle
creation procedures for algorithms such as Deutsch-Jozsa, Bernstein-Vazirani,
Simon’s, and Grover’s algorithm, which serve as the foundation for quantum
research in various problem domains. Workflows for implementing full routines
like the quantum Fourier transform and quantum teleportation protocols are
included to demonstrate a few challenging workloads. Each algorithmic
implementation is created with its respective theoretical underpinning,
practical realization, and experimental considerations.

####  III-A5 Gate Operations and Manipulation

Tasks here involve the manipulation or creation of quantum gates. Here, the
focus is on the manipulation, transformation, and strategic use of quantum
gates, operators, and layouts within circuits. It includes modifying gates or
creating gate-based circuits tailored to meet specific computational or
hardware-imposed constraints, which are crucial for optimizing circuit
functionality and performance. This tests the LLMs understanding of the
fundamental building blocks of quantum circuits and their manipulation to
achieve desired quantum states or operations using Qiskit’s classes and
modules like the transpiler and quantum information module to achieve the
results.

####  III-A6 Visualization and Post-Processing

This category comprises of tasks that require the visualization of quantum
operations and the post-processing of the output. It is vital for interpreting
the outcomes of quantum operations and effectively communicating these results
within the scientific community.

####  III-A7 Advanced Circuit Manipulation

Advanced manipulation techniques such as circuit refinement, optimization, and
transpilation are covered under this category. These tasks require complex
manipulations of circuits such as optimizing circuit layouts or customizing
gate operations for specific hardware constraints to enhance efficiency or
compatibility.

####  III-A8 Quantum Circuit Serialization

Covers the serialization and formatting of quantum circuits into standardized
descriptions or machine-readable formats. This process facilitates the
storage, sharing, and further processing of quantum circuits, ensuring their
broader applicability and integration into various quantum computing
platforms.

The repository for the paper will contain a dataset that conforms to the
following structure format:

  * •

task_id: Each task within the dataset is assigned a unique identifier
formatted as “qiskitCodeAssistant/{number}.” This identifier is crucial for
tracking and referencing tasks within the dataset, facilitating easy access
and systematic analysis across different studies or evaluations.

  * •

prompt: The prompt defines the specific quantum computing problem that the LLM
needs to solve by generating appropriate quantum code using Qiskit. It frames
the challenge, outlining the requirements and objectives clearly to guide the
LLMs code generation process effectively.

  * •

canonical_solution: This attribute provides a reference implementation that
effectively fulfills the requirements set out in the prompt. Serving as a
benchmark, the canonical solution aids researchers and developers in
understanding potential approaches to solving the task, offering a baseline
against which the LLM-generated solutions can be compared.

  * •

test: The test component is essential for the automated evaluation of the code
generated by the LLM. It includes a Python unit test function that performs a
series of checks to ensure that the generated code not only runs correctly but
also adheres strictly to the specifications detailed in the prompt. These
tests assess various aspects of the output, such as its type, attributes, and
functional correctness, providing a robust mechanism for validating the
efficacy of the LLM model.

  * •

entry_point: The entry point specifies the function within the generated code
that the test script will call to begin the evaluation process. This ensures
that the evaluation system accurately assesses the correct portion of the
LLM’s output, focusing on the implementation that is intended to solve the
task. It is pivotal in aligning the testing procedure with the intended
functionality of the generated code, guaranteeing that the evaluation reflects
the true performance of the LLM-generated solution.

  * •

difficulty_scale: This attribute categorizes each task by complexity into one
of three levels: basic, intermediate, or difficult. The difficulty scale is a
critical tool for benchmarking, as it allows researchers to measure the
performance of models across tasks of varying complexity. This facilitates a
nuanced analysis of the models’ capabilities, identifying strengths and
weaknesses in handling different levels of quantum programming challenges.

###  III-B Diversity and Complexity

The dataset covers a wide range of workloads in the context of quantum
computing from a practitioner’s perspective using Qiskit. The complexity of
the tasks varies to include entry-level tasks that familiarize models with
Qiskit’s syntax and semantics as well as advanced tasks accommodating varying
dependencies and workflows. This variety ensures that models are tested across
a comprehensive range of scenarios, promoting robustness and adaptability in
the models code generation.

In constructing our dataset, we designed 101 tasks and categorized them based
on the anticipated level of difficulty: basic, intermediate, and difficult.
The distribution of these tasks is as follows: 54 are designated as basic, 45
as intermediate, and 2 as difficult.

####  III-B1 Basic Level Tasks

Basic tasks typically involve simple quantum circuits and fundamental Qiskit
functionalities. These tasks are straightforward and require minimal language
comprehension or logical reasoning. For example, one task (Example 1) involves
creating a $\phi^{+}$ Bell state, simulating it using the Aer simulator, and
returning a counts dictionary. This is commonly used as a ”hello world”
example in quantum computing. The validation process checks whether the result
is a dictionary containing ”00” and ”11” states, with the probability of one
state between 0.4 and 0.6. Similarly, in another task (Example 2), the
objective is to generate a GHZ State, and, depending on a Boolean parameter,
return either a Matplotlib figure of the circuit or the circuit object itself,
with validation checks for both outputs.

####  III-B2 Intermediate Level Tasks

Intermediate tasks require the use of complex quantum algorithms and multiple
Qiskit functionalities, enhancing the need for reasoning and problem-solving
capabilities. An instance is Example 3, where the task involves designing a
CHSH game [19] circuit that takes bits from Alice and Bob as parameters and
returns the measured quantum circuit. The validation includes checks on the
number of qubits, circuit depth, and utilized gates. Another task (Example 4)
instructs participants to create a pulse schedule using Qiskit Pulse for a
specified drive channel, with detailed requirements for pulse duration and
amplitude, followed by a delay and a pulse repetition. The verification
ensures compliance with the defined attributes.

Other intermediate tasks try to simulate use cases that quantum developers are
likely to have, rather than just assessing comprehension and logical
reasoning. These tasks focus on creating utility functions to manipulate
Qiskit objects. Examples include splitting a circuit at each barrier
operation, creating a basic transpiler pass (which users could use as a
template), and converting the output from a circuit sampler result to a list
of Python bool objects.

####  III-B3 Difficult Level Tasks

Only two tasks are classified as difficult, signifying their reliance on
complex quantum algorithms and a high level of comprehension, reasoning, and
problem-solving skills. For instance, Example 5 queries the model with
generating an encryption key from the circuit and the sender’s basis using the
BB84 protocol. This requires an in-depth understanding of the BB84 algorithm
and is verified by ensuring the results match the expected outcome under
controlled test conditions.

By organizing the tasks into three difficulty levels, we seek to thoroughly
assess a wide range of problems solved using Qiskit, from basic Qiskit
operations to advanced Quantum Algorithms.

⬇

from qiskit import QuantumCircuit

from qiskit_aer import Aer

from qiskit.compiler import transpile

def run_bell_state_simulator():

"""

Define a phi plus bell state using Qiskit,

simulate it using the Aer simulator,

and return the counts dictionary.

"""

bell = QuantumCircuit(2)

bell.h(0)

bell.cx(0, 1)

bell.measure_all()

backend = Aer.get_backend("aer_simulator")

result = backend.run(transpile(bell, backend), shots=1000).result()

return result.get_counts(bell)

def check(candidate):

result = candidate()

assert isinstance(result, dict)

assert result.keys() == {"00", "11"}

assert 0.4 < (result["00"] / sum(result.values())) < 0.6

run_bell_state_simulator()

Example 1: Example from the Qiskit HumanEval dataset with “basic” difficulty
scale.

###  III-C Emphasizing Simulated and Real System Runs

This dataset is designed to also provide a robust framework for assessing the
performance of generated quantum code under both simulated conditions and on
actual quantum hardware. The dual-environment testing is critical for a
comprehensive evaluation of the LLMs code generation capablities in the
quantum computing context. The simulation framework used is based on Qiskit
Aer and real system runs are based on Qiskit Runtime interfaces to IBM Quantum
backends on IBM Quantum.

Simulation plays a critical role in the field of quantum computing,
particularly in the developmental stages of quantum algorithms. Within the
Qiskit framework, the Aer module provides powerful tools for simulating
quantum circuits. Simulators allow for the comprehensive testing of quantum
algorithms in a controlled environment. Researchers can explore the
theoretical correctness and efficiency of algorithms without the need for
actual quantum hardware, which is often less accessible and more costly to
operate. Qiskit Aer offers advanced noise models that mimic the behavior of
real quantum devices. By running simulations that include realistic noise
conditions, developers can predict how algorithms will perform on actual
quantum hardware, identifying potential issues and optimizations early in the
development process. Simulators help in assessing the resource requirements of
quantum algorithms, including the number of qubits needed and the
computational complexity. This information is crucial for scaling algorithms
and preparing them for deployment on real quantum systems.

While simulations are valuable, testing and validating quantum algorithms on
actual quantum hardware is indispensable. The ultimate test of any quantum
algorithm’s efficacy comes from its performance on real quantum hardware. The
Qiskit HumanEval dataset includes runs on actual quantum processors, such as
those available through IBM Quantum services. These real system runs are
indispensable for validating the feasibility and robustness of quantum code
generated from LLM models. Each quantum processor has unique characteristics
and imperfections, such as qubit connectivity, gate fidelity, and decoherence
times. Running algorithms on actual hardware allows researchers to understand
how these factors impact performance and to tailor algorithms to specific
hardware constraints. By executing algorithms and code on real quantum
systems, researchers can evaluate their practical feasibility and scalability.
This real-world testing is crucial for transitioning quantum algorithms from
theoretical constructs to practical tools that can solve real-world problems.
Real system runs serve as a benchmark for the effectiveness of quantum
algorithms. They provide a measure of validation that simulations alone cannot
offer, confirming that the algorithms can operate under the constraints and
imperfections of actual quantum hardware.

In the context of the Qiskit HumanEval dataset, both simulated and real system
runs using Qiskit Runtime are integral for assessing the generative LLM
models’ ability to produce viable and efficient quantum code. Simulations
provide a first layer of validation and optimization, while real system runs
offer the ultimate test of the algorithms’ applicability and effectiveness in
true quantum environments. This dual approach ensures a comprehensive
evaluation of quantum code generated and LLMs capablities of generating code
for various interfaces, promoting a deeper understanding of LLMs capabilities
and limitations for a particular SDK.

⬇

from qiskit import QuantumCircuit

def create_ghz(drawing=False):

"""

Generate a QuantumCircuit for a 3 qubit GHZ State and measure it.

If ‘drawing‘ is True, return a Matplotlib drawing of the circuit,

otherwise return the circuit object.

"""

ghz = QuantumCircuit(3)

ghz.h(0)

ghz.cx(0, 1)

ghz.cx(0, 2)

ghz.measure_all()

if drawing:

return ghz.draw(output="mpl")

return ghz

def check(candidate):

from qiskit.quantum_info import Statevector

import math

import matplotlib.pyplot as plt

circuit = create_ghz()

assert circuit.data[-1].operation.name == "measure"

circuit.remove_final_measurements()

ghz_statevector = (

Statevector.from_label("000") + Statevector.from_label("111")

) / math.sqrt(2)

assert Statevector.from_instruction(circuit).equiv(ghz_statevector)

drawing = create_ghz(drawing=True)

assert isinstance(drawing, matplotlib.figure.Figure)

create_ghz()

Example 2: Example from the Qiskit HumanEval dataset with “basic” difficulty
scale.

⬇

from qiskit import QuantumCircuit

from numpy import pi

def chsh_circuit(alice: int, bob: int) -> QuantumCircuit:

"""

Design the CHSH circuit that takes bits of Alice and Bob as input

and return the Quantum Circuit after measuring.

"""

qc = QuantumCircuit(2, 2)

qc.h(0)

qc.cx(0, 1)

qc.barrier()

if alice == 0:

qc.ry(0, 0)

else:

qc.ry(-pi / 2, 0)

qc.measure(0, 0)

if bob == 0:

qc.ry(-pi / 4, 1)

else:

qc.ry(pi / 4, 1)

qc.measure(1, 1)

return qc

def check(candidate):

result = candidate(0, 1)

assert isinstance(result, QuantumCircuit)

assert result.num_qubits == 2

assert result.width() == 4

assert result.depth() == 4

assert set({’ry’: 2, ’measure’: 2, ’h’: 1, ’cx’:
1}.items()).issubset(set(result.count_ops().items()))

chsh_circuit()

Example 3: Example from the Qiskit HumanEval dataset with “intermediate”
difficulty scale.

###  III-D Accessibility and Ethics

The dataset will be openly available to the research community to promote
transparency and reproducibility for this research direction in quantum
computing. Care has been taken to exclude any proprietary information or data
that could lead to ethical concerns, focusing solely on open source publicly
available knowledge and problem scenarios.

###  III-E Compatiblity

As of the time of writing, the codebase is compatible with Qiskit $\geq 1.0$
and is expected to evolve alongside the release of new Qiskit versions that
offer enhanced capabilities.

##  IV Experiment results

We tested Qiskit HumanEval on different state-of-the-art open-source Code
LLMs. We also introduce in this paper a new Qiskit model.

⬇

from qiskit import pulse

from qiskit_ibm_runtime.fake_provider import FakeBelem

from qiskit.pulse import DriveChannel, Constant, Play, Delay

def pulse_schedule_with_constant_and_delay():

"""

Using Qiskit Pulse, create a schedule with a constant pulse on drive channel
0,

featuring a duration of 160 and an amplitude of 0.1 and name this schedule

’pulse_schedule_with_constant_and_delay’. Use the FakeBelem backend for
configuration.

After creating the pulse, add a delay of 400 to the schedule, then replay the
same pulse.

Return the completed pulse schedule.

"""

backend = FakeBelem()

constant_pulse = Constant(duration=160, amp=0.1)

drive_chan = DriveChannel(0)

with pulse.build(backend=backend,
name=’pulse_schedule_with_constant_and_delay’) as pulse_sched:

pulse.play(constant_pulse, drive_chan)

pulse.delay(400, drive_chan)

pulse.play(constant_pulse, drive_chan)

return pulse_sched

def check(candidate):

pulse_sched = candidate()

constant_pulses = 0

delays = 0

for inst in pulse_sched.instructions:

if isinstance(inst, Play):

if isinstance(inst.pulse, Constant):

constant_pulses += 1

elif isinstance(inst, Delay):

delays += 1

assert constant_pulses == 2, ’Schedule should contain exactly two Constant
pulses.’

assert delays == 1, ’Schedule should contain exactly one Delay instruction.’

assert pulse_sched.name == ’pulse_schedule_with_constant_and_delay’

pulse_schedule_with_constant_and_delay()

Example 4: Example from the Qiskit HumanEval dataset with “intermediate”
difficulty scale.

Our base model is a transformer decoder-only model with 8 Billion parameters
using multi-query attention, rotary position embeddings, and $4096$ context
window. It was pretrained on $4$ Trillion tokens across $116$ programming
languages [20] and is available on Huggingface (ibm-granite/granite-8b-code-
base).

⬇

from qiskit import QuantumCircuit

from qiskit_aer import Aer

from numpy.random import randint

def bb84_circuit_generate_key(senders_basis: [int], circuit: QuantumCircuit)
-> str:

"""

Write the function to generate the key from the circuit and the sender’s

basis generated by the sender using BB84 protocol.

"""

n = len(senders_basis)

receivers_basis = randint(2, size=n)

for i in range(n):

if receivers_basis[i]:

circuit.h(i)

circuit.measure_all()

key = Aer.get_backend(’qasm_simulator’).run(circuit.reverse_bits(),
shots=1).result().get_counts().most_frequent()

encryption_key = ’’

for i in range(n):

if senders_basis[i] == receivers_basis[i]:

encryption_key += str(key[i])

return encryption_key

def check(candidate):

from qiskit.quantum_info import Statevector

from numpy.random import seed

seed(12345)

basis = [1, 0, 0, 1, 1]

circuit = QuantumCircuit(5)

circuit.x([3, 4])

circuit.h([0, 3, 4])

result = candidate(basis, circuit)

assert result == "11"

bb84_circuit_generate_key()

Example 5: Example from the Qiskit HumanEval dataset with “difficult”
difficulty scale.

To improve the performance at generating Qiskit, we extended the pre-training
with Qiskit python code and jupyter notebooks. Our Qiskit dataset was
collected in April 2024, that is after the latest 1.0 Qiskit release. We used
only data with the following licenses: Apache 2.0, MIT, the Unlicense, Mulan
PSL Version 2, BSD-2, BSD-3, and Creative Commons Attribution 4.0. Whilst
there is a large amount of Qiskit in the open-source, much of it is
deprecated. To ensure both diversity and quality in our data mixture we
decided to keep only data updated after 2023, and oversampled the most recent
data from Qiskit [21], Qiskit-Community [22], and Qiskit-Extensions [23],
which all contain the highest quality Qiskit code available. After
deduplication, and applying various cleaning filters, our Qiskit dataset has
about $50$ Million tokens. For extend pre-training, the data is packed in
$4096$-long sequences with a separator between each samples. We trained for 3
epochs using a learning rate of $1\times 10^{-5}$ decayed with a cosine
schedule, and a batch size of $64$.

To improve natural language understanding, we further instruct-tuned the
model, following the octopack approach as described in [13]. We mixed chat
data from openassistant ($8$k samples) and git commit data from commitpackft
($5$k samples). We also added Qiskit synthetic data: $2.7$k question/answer
pairs generated from tutorials using Mixtral 8x7B Instruct [24], and $1$k
synthetic prompt/code pairs, whose execution accuracy were validated using
synthetically-generated unittests. All the sequences were padded on the left
and we used a $2048$ sequence length. We trained on $3$ epochs using a batch
size of $32$, and a learning rate of $8\times 10^{-6}$ decayed with a cosine
schedule.

We present the results on HumanEval (HE) and Qiskit HumanEval (QHE) in Table
II for different baselines and our Qiskit model. The baselines include $7$B,
$15$B, and $30$+B open-source code LLMs. Our Qiskit model granite-8b-code-qk
performs better than all the other baselines on QHE. The pass rate jumps
$17.8$ points compared with granite-8b-code-base which shows the efficiency of
our tuning approach. In Table III, we breakout the scores by difficulty scale.
Our model is the best at the basic and intermediate levels. No model is
currently able to pass either of the $2$ difficult tests.

TABLE II: HumanEval (HE) and Qiskit-HumanEval (QHE) pass@$1$ computed using greedy decoding. Model |  HE |  QHE
---|---|---
CodeLlama-34b-Python-hf |  $\mathbf{52.43}$% |  $26.73$%
deepseek-coder-33b-base |  $49.39$% |  $39.6$%
starcoder2-15b |  $45.12$% |  $37.62$%
codegemma-7b |  $42.68$% |  $24.75$%
granite-8b-code-base |  $39.02$% |  $28.71$%
granite-8b-code-qk |  $38.41$% |  $\mathbf{46.53}$%
TABLE III: QHE pass counts for the three difficulty levels. There are $54$ basic, $45$ intermediate, and $2$ difficult tests. Model |  basic |  interm. |  difficult
---|---|---|---
CodeLlama-34b-Python-hf |  $19/54$ |  $8/45$ |  $0/2$
deepseek-coder-33b-base |  $30/54$ |  $10/45$ |  $0/2$
starcoder2-15b |  $26/54$ |  $12/45$ |  $0/2$
codegemma-7b |  $20/54$ |  $5/45$ |  $0/2$
granite-8b-code-base |  $21/54$ |  $8/45$ |  $0/2$
granite-8b-code-qk |  $\mathbf{32/54}$ |  $\mathbf{15/45}$ |  $0/2$

##  V Discussion

The Qiskit HumanEval dataset represents a significant advancement in the
intersection of GenAI and quantum computing. As previously mentioned, this
dataset is believed to be the first of its kind, designed specifically to
evaluate the performance of code large language models (LLMs) in the context
of generating code for quantum computing. As seen throughout this paper, the
creation of this dataset has adhered to several strict principles and
foundations. Each proposed task is novel, original, and has been peer-reviewed
by a panel of experts to ensure the accuracy of the prompts and tests in
relation to the intended task. The dataset is not created or designed to cater
to or be complacent with models already being trained for Qiskit. As observed
in Table III, the data shows a similar trend and similar results or challenges
across different models when solving problems for various difficulty scales.
Although our model granite-8b-code-qk performs better than others, its
behavior is aligned or similar to models such as deepseek-coder-33b-base.

Given the dynamic nature of quantum computing and Qiskit, which are subject to
continuous advancements, including new algorithms, techniques, and
enhancements, we anticipate that the project will evolve accordingly. At the
time this paper was drafted, the dataset consisted of 101 tests. The complete
dataset is scheduled for release in the upcoming months, coinciding with the
final publication of this paper. The preliminary public release will offer a
set of 150 tests, which align with the descriptions provided in Section 2. The
primary objective of this initial release is to evaluate the code Language
Models in generating quantum code for various quantum tasks, encompassing
different levels of complexity and prerequisite knowledge in both code and
quantum computing concepts. In keeping with our commitment to accessibility
and community collaboration, the dataset will be made publicly available as
open source in Q3 2024. This release will enable users from around the world
to contribute to and benefit from the dataset, fostering a diverse and robust
quantum computing community. Furthermore, this public availability will enable
other code LLMs to assess their performance in the quantum coding domain or
even create leaderboards for this subject. To maximize the dataset’s relevance
and effectiveness, the QHE team will encourage feedback from all users. This
collaborative approach will help in identifying areas for improvement and in
ensuring that the dataset meets the diverse needs of the community. Detailed
guidelines will be provided for those interested in contributing to the
dataset’s development on a public git repository, whether through the addition
of new tasks, enhancement of existing ones, or provision of translations and
documentation.

In terms of planned updates, the current dataset is compatible with Qiskit
version $\geq 1.0$. As the Qiskit SDK continues to evolve, the dataset will
need to be updated to ensure compatibility with new Qiskit versions and
maintaining its relevance and utility for researchers and practitioners. The
dataset will be periodically updated to reflect community user feedback and
broaden its scope and utility. These enhancements will be documented in
subsequent versions, keeping users informed and equipped with the latest
tools.

Considering possible expansions and future iterations of this dataset, there
are several opportunities to broaden its scope. Future expansion plans for the
dataset may involve incorporating tasks formulated in OpenQASM 3.0 [25], which
would increase its compatibility with various libraries and expand its
applicability. Also, currently, the dataset is focused on evaluating code
generation. However, it could also be enhanced to include tasks related to
code explainability, repair, or translation.

## Acknowledgment

The authors thank the data and model factory who collected the code data and
trained the base model, in particular Mayank Mishra, Rameswar Panda, Gaoyuan
Zhang, Matthew Stallone, and Hima Patel. We also thank Atin Sood for helping
setting up the Qiskit Code Assistant service, and Xuan Liu for support and
management.

## References

  * [1] J. Cruz-Benito, et al., “A deep-learning-based proposal to aid users in quantum computing programming,” in _Learning and Collaboration Technologies. Learning and Teaching_ , P. Zaphiris and A. Ioannou, Eds. Cham: Springer International Publishing, 2018, pp. 421–430.
  * [2] N. Dupuis, et al., “Qiskit Code Assistant: Training LLMs for generating Quantum Computing Code,” _arXiv preprint arXiv:2405.19495_ , 2024\.
  * [3] J. M. Murillo, et al., “Challenges of quantum software engineering for the next decade: The road ahead,” _arXiv preprint arXiv:2404.06825_ , 2024.
  * [4] Unitary Fund, “2023 Quantum Open Source Survey,” Dec 2023. [Online]. Available: https://unitaryfund.github.io/survey-website/
  * [5] Qiskit contributors, “Qiskit: An open-source framework for quantum computing,” 2023.
  * [6] A. Javadi-Abhari, M. Treinish, K. Krsulich, C. J. Wood, J. Lishman, J. Gacon, S. Martiel, P. D. Nation, L. S. Bishop, A. W. Cross _et al._ , “Quantum computing with qiskit,” _arXiv preprint arXiv:2405.08810_ , 2024.
  * [7] J. Liu, et al., “Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation,” 2023.
  * [8] M. Chen, et al., “Evaluating Large Language Models Trained on Code.” 2021.
  * [9] Z. Liang, et al., “Unleashing the potential of llms for quantum computing: A study in quantum architecture design,” _arXiv preprint arXiv:2307.08191_ , 2023.
  * [10] F. Cassano, et al., “Multipl-e: A scalable and extensible approach to benchmarking neural code generation,” 2022.
  * [11] Y. Ding, et al., “Crosscodeeval: A diverse and multilingual benchmark for cross-file code completion,” 2023.
  * [12] T. Liu, C. Xu, and J. McAuley, “Repobench: Benchmarking repository-level code auto-completion systems,” 2023.
  * [13] N. Muennighoff, et al., “OctoPack: Instruction Tuning Code Large Language Models,” 2023.
  * [14] F. Cassano, et al., “Can it edit? evaluating the ability of large language models to follow code editing instructions,” 2023.
  * [15] A. Gu, B. Rozière, et al., “Cruxeval: A benchmark for code reasoning, understanding and execution,” 2024.
  * [16] J. Austin, et al., “Program synthesis with large language models,” 2021\.
  * [17] Y. Lai, et al., “Ds-1000: A natural and reliable benchmark for data science code generation,” 2022.
  * [18] L. Ben Allal, et al., “A framework for the evaluation of code generation models,” https://github.com/bigcode-project/bigcode-evaluation-harness, 2022.
  * [19] J. F. Clauser, et al., “Proposed experiment to test local hidden-variable theories,” _Phys. Rev. Lett._ , vol. 23, pp. 880–884, Oct 1969. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevLett.23.880
  * [20] M. Mishra, et al., “Granite code models: A family of open foundation models for code intelligence,” _arXiv:2405.04324_ , 2024.
  * [21] “Qiskit,” https://github.com/Qiskit/qiskit, 2024.
  * [22] “Qiskit Community,” https://github.com/qiskit-community, 2024.
  * [23] “Qiskit Extensions,” https://github.com/Qiskit-Extensions, 2024.
  * [24] A-Q. Jiang, et al., “Mixtral of experts,” _arXiv:2401.04088_ , 2024\.
  * [25] A. Cross, et al., “Openqasm 3: A broader and deeper quantum assembly language,” _ACM Transactions on Quantum Computing_ , vol. 3, no. 3, sep 2022. [Online]. Available: https://doi.org/10.1145/3505636


# The $L_{p}$ Gauss image problem

Chuanxi Wu  Faculty of Mathematics and Statistics, Hubei Key Laboratory of
Applied Mathematics, Hubei University, Wuhan 430062, P.R. China
<EMAIL_ADDRESS>,  Di Wu  Faculty of Mathematics and Statistics, Hubei Key
Laboratory of Applied Mathematics, Hubei University, Wuhan 430062, P.R. China
<EMAIL_ADDRESS>and  Ni Xiang  Faculty of Mathematics and Statistics,
Hubei Key Laboratory of Applied Mathematics, Hubei University, Wuhan 430062,
P.R. China<EMAIL_ADDRESS>
###### Abstract.

In this paper we study the $L_{p}$ Gauss image problem, which is a
generalization of the $L_{p}$ Aleksandrov problem and the Gauss image problem
in convex geometry. We obtain the existence result for the $L_{p}$ Gauss image
problem in two cases (i) $p>0$ or (ii) $p<0$ with the given even measures.

Keywords: the $L_{p}$ Gauss image problem, Surface area measure, Curvature
measure, Existence of solution, Blaskchke selection theorem.

MSC 2020: Primary 35J96, Secondary 52A20.

##  1\. Introduction

Let $\mathcal{K}^{n}_{0}$ denote the set of convex bodies in $\mathbb{R}^{n}$
which contains the origin in its interior. For $K\in\mathcal{K}^{n}_{0}$, its
support function, $h_{K}$, is defined by

$h_{K}(x):=\max_{y\in K}\langle
y,x\rangle,\quad\forall\,x\in\mathbb{S}^{n-1},$

where $\langle y,x\rangle$ is the standard inner product of $x$ and $y$ in
$\mathbb{R}^{n}$.

Suppose $K,L\in\mathcal{K}^{n}_{0}$ and $t\geq 0$, the Minkowski combination,
$K+tL\in\mathcal{K}^{n}_{0}$, is given by

$h_{K+tL}=h_{K}+th_{L};$

for negative $t$, $K+tL$ can be defined if $|t|$ is sufficient small.
Aleksandrov’s variational formula shows that

$\frac{d}{dt}V(K+tL)\bigg{|}_{t=0}=\int_{\mathbb{S}^{n-1}}h_{L}(x)dS(K,x),\quad\forall
L\in\mathcal{K}^{n}_{0},$

where $V(\cdot)$ denotes the volume functional and $S(K,\cdot)$ is the surface
area measure.

A nature extension is $L_{p}$ Minkowski sum, which was first defined by Firey
in case $p\geq 1$. Suppose $K,L\in\mathcal{K}^{n}_{0}$ and $t\geq 0$, the
$L_{p}$ Minkowski combination, $K+_{p}t\cdot L\in\mathcal{K}^{n}_{0}$, is
defined by

$h^{p}_{K+_{p}t\cdot L}=h^{p}_{K}+th^{p}_{L}.$

In the early 1900’s, $K+_{p}t\cdot L$ can be defined for negative $t$ if $|t|$
is sufficient small. Lutwak [36] showed the variational formula

$\frac{d}{dt}V(K+_{p}t\cdot
L)\bigg{|}_{t=0}=\frac{1}{p}\int_{\mathbb{S}^{n-1}}h^{p}_{L}(x)dS_{p}(K,x),\quad\forall
L\in\mathcal{K}^{n}_{0},$

where $S_{p}(K,\cdot)$ is the $L_{p}$ surface area measure, satisfying

(1.1) $dS_{p}(K,\cdot)=h_{K}^{1-p}dS(K,\cdot).$

Thus by (1.1), the $L_{p}$ surface area measure can be defined for any
$p\in\mathbb{R}$.

Suppose $K\in\mathcal{K}^{n}_{0}$, $K^{\ast}$ stands for the polar body of
$K$, which is given by

(1.2) $K^{\ast}=\bigcap_{y\in K}\\{x\in\mathbb{R}^{n}:\langle x,y\rangle\leq
1\\}.$

By combining the concept of $L_{p}$ Minkowski combination with that of
polarity, we obtain another kind of combination, the $L_{p}$ harmonic
combination, $K\hat{+}_{p}t\cdot L\in\mathcal{K}^{n}_{0}$, is defined by

$K\hat{+}_{p}t\cdot L=(K^{*}+_{p}t\cdot L^{*})^{*}.$

Huang, Lutwak, Yang and Zhang [25] considered the entropy functional

(1.3) $\mathcal{E}(K)=-\int_{\mathbb{S}^{n-1}}\log h_{K}(x)dx,$

and got the variational formula

$\frac{d}{dt}\mathcal{E}(K\hat{+}_{p}t\cdot
L)\bigg{|}_{t=0}=\frac{1}{p}\int_{\mathbb{S}^{n-1}}\rho^{-p}_{L}(u)dJ_{p}(K,u),\quad\forall
L\in\mathcal{K}^{n}_{0},$

where $\rho_{L}$ is the radial function of $L$, given by

$\rho_{L}(u):=\max\\{t>0:tu\in L\\},\quad\forall\,u\in\mathbb{S}^{n-1}.$

They proved the $L_{p}$ integral curvature $J_{p}(K,\cdot)$ satisfies

(1.4) $dJ_{p}(K,\cdot)=\rho_{K}^{p}dJ(K,\cdot),$

where $J(K,\cdot)$ is the Aleksandrov integral curvature.

For any Borel measurable subset $\omega\subset\mathbb{S}^{n-1}$, the radial
Gauss image of $\omega$, $\boldsymbol{\alpha}_{K}(\omega)$, is given by

$\boldsymbol{\alpha}_{K}(\omega)=\\{x\in\mathbb{S}^{n-1}:\langle\rho_{K}(u)u,x\rangle=h_{K}(x)\text{
for some }u\in\omega\\}.$

Then $J(K,\cdot)$ is the spherical Lebesgue measure of the radial Gauss image
$\boldsymbol{\alpha}_{K}$, that is,

(1.5) $J(K,\omega)=\mathcal{H}^{n-1}(\boldsymbol{\alpha}_{K}(\omega)).$

Recently, Boroczky, Lutwak, Yang, Zhang and Zhao [5] proposed the Gauss image
measure $\lambda(K,\omega)$, which is a generalization of the Aleskandrov
integral measure. We state it more precisely below.

######  Definition 1.1.

Let $\lambda$ be a Borel measure on $\mathbb{S}^{n-1}$, and
$K\in\mathcal{K}^{n}_{0}$. Then the Gauss image measure of $\lambda$ via $K$
is defined by

(1.6) $\lambda(K,\omega)=\lambda(\boldsymbol{\alpha}_{K}(\omega)),$

where $\omega$ is a Lebesgue measurable subset of $\mathbb{S}^{n-1}$.

Based on (1.3), (1.5) and (1.6), it is nature to consider the functional

(1.7) $G(K)=-\int_{\mathbb{S}^{n-1}}\log h_{K}(x)d\lambda(x).$

And its variational formulas is

$\frac{d}{dt}G(K\hat{+}_{p}t\cdot
L)\bigg{|}_{t=0}=\frac{1}{p}\int_{\mathbb{S}^{n-1}}\rho_{L}^{-p}(u)d\lambda_{p}(K,u),\quad\forall
L\in\mathcal{K}^{n}_{0},$

where $\lambda_{p}(K,\cdot)$ is the $L_{p}$ Gauss image measure, satisfying

(1.8) $d\lambda_{p}(K,\cdot)=\rho_{K}^{p}d\lambda(K,\cdot).$

It is clear that $\lambda_{0}(K,\cdot)=\lambda(K,\cdot)$, and (1.8) becomes
(1.4) if $\lambda(K,\cdot)$ is $J(K,\cdot)$. Therefore, the $L_{p}$
Aleksandrov measure and the Gauss image measure are special cases of the
$L_{p}$ Gauss image measure.

The $L_{p}$ Gauss image problem. _For a fixed $p\in\mathbb{R}$, suppose
$\lambda$ and $\mu$ are two Borel measures defined on the Borel measurable
subsets of $\mathbb{S}^{n-1}$. What are the necessary and sufficient
conditions, on $\lambda$ and $\mu$, such that there exists a convex body $K$,_

$\mu=\lambda_{p}(K,\cdot)$

_on the Borel subsets of $\mathbb{S}^{n-1}$? And if such a body exists, to
what extent is it unique? _

When $\lambda$ is spherical Lebesgue measure, the $L_{p}$ Gauss image problem
is just the $L_{p}$ Aleksandrov problem, see [1, 2, 3, 25]. The $L_{0}$ Gauss
image problem is just the Gauss image problem which was first mentioned in
[5], and the existence of smooth solution for the Gauss image problem was in
[14]. It is necessary to contrast the $L_{p}$ Gauss image problem with the
various Minkowski problems and dual Minkowski problems that have been
extensively studied, see [8, 11, 15, 16, 27, 29, 30, 34, 35, 36, 37, 38, 40,
44, 45] for the $L_{p}$-Minkowski problem, [7, 21, 23, 24, 32, 42, 43] for the
dual Minkowski problem, [6, 9, 10, 25, 26, 31, 39] for the $L_{p}$ dual
Minkowski problem, [4, 20, 22, 28] for the Orlicz Minkowski problem, [12, 13,
18, 19, 33] for the dual Orlicz Minkowski problem, [17] for the Orlicz
Aleskandrov problem.

The existence result for the $L_{p}$ Gauss image problem when $p>0$ will be
presented in the followong. The idea goes back as for as [25].

######  Theorem 1.2.

Suppose $p>0$. If $\lambda$ and $\mu$ are two finite Borel measures on
$\mathbb{S}^{n-1}$ which satisfy

(1) $\lambda$ is absolutely continuous with respect to spherical Lebesgue
measure;

(2) $\lambda(A)>0$ for any nonempty open set $A\subset\mathbb{S}^{n-1}$;

(3) $\mu$ is not concentrated in any closed hemisphere of $\mathbb{S}^{n-1}$.
Then there exists a convex body $K$ such that $\mu=\lambda_{p}(K,\cdot)$.

If the given measures are even, the third condition in Theorem 1.2 is
naturally satisfied, and we can get the existence result for $p<0$.

######  Theorem 1.3.

Suppose $p<0$. If $\lambda$ and $\mu$ are two finite, even Borel measures on
$\mathbb{S}^{n-1}$ which satisfy

(1) $\lambda$ is absolutely continuous with respect to spherical Lebesgue
measure;

(2) $\lambda(A)>0$ for any nonempty open set $A\subset\mathbb{S}^{n-1}$;

(3) $\mu$ is vanishes on great sub-spheres of $\mathbb{S}^{n-1}$.
Then there exists an origin-symmetric convex body $K$ such that
$\mu=\lambda_{p}(K,\cdot)$.

In particular, when $\mu$ has a density, say $f$, and $\lambda$ has a density,
say $g$, the $L_{p}$ Gauss image problem asks: Under what conditions on the
two given functions $f,g:\mathbb{S}^{n-1}\rightarrow[0,\infty)$, does there
exist a solution $h:\mathbb{S}^{n-1}\rightarrow(0,\infty)$, that is the
support function of a convex body $K^{*}$, to the Monge-Ampère equation

(1.9) $g\bigg{(}\frac{\nabla h+hx}{|\nabla
h+hx|}\bigg{)}\frac{h^{1-p}}{(|\nabla
h|^{2}+h^{2})^{\frac{n}{2}}}\det(\nabla^{2}h+hI)=f(x)\quad\text{on}\quad\mathbb{S}^{n-1}.$

######  Remark 1.4.

The weak solution of the equation (1.9) for $g\equiv 1$ was solved by Huang,
Lutwak, Yang and Zhang [25].

It is worth pointing out that if $\lambda$ and $\mu$ have densities, the weak
solution of the equation (1.9) can be obtained according to Theorem 1.2 and
Theorem 1.3.

######  Remark 1.5.

Assume $g>0$.

(1) For $p>0$, if for any hemisphere $\Theta$,

$\int_{\Theta}f(x)dx>0,$

then the equation (1.9) has a strictly positive solution.

(2) For $p<0$, if $f$ and $g$ are even functions, and if

$\int_{\mathbb{S}^{n-1}}f(x)dx>0,$

then the equation (1.9) has a strictly positive even solution.

This paper is organized as follows. In section 2, we give some basic knowledge
about convex body. In section 3, The $L_{p}$ Gauss image measure will be
given, based on the radial Gauss image. In section 4, the variational formulas
will be obtained and in the last section, Theorem 1.2 and Theorem 1.3 will be
proved.

##  2\. Preliminaries

In this section, some notions and facts will be set up, the details can be
found in [41].

Let $K$ be a convex body in $\mathbb{R}^{n}$, which means $K$ is a compact,
convex subset in $\mathbb{R}^{n}$ with non-empty interior. And
$\mathcal{K}^{n}=\\{K:K$ is a convex body in $\mathbb{R}^{n}\\}$,
$\mathcal{K}^{n}_{e}=\\{K\in\mathcal{K}^{n}:K$ is origin-symmetric $\\}$.

Suppose $K\in\mathcal{K}^{n}_{0}$, recall $h_{K}$ and $\rho_{K}$ denote the
support function and the radial function of $K$, respectively,

(2.1) $h_{K}(x):=\max_{y\in K}\langle
y,x\rangle,\quad\forall\,x\in\mathbb{S}^{n-1},$

and

(2.2) $\rho_{K}(u):=\max\\{t>0:tu\in K\\},\quad\forall\,u\in\mathbb{S}^{n-1}.$

Note that

(2.3) $\partial K=\\{\rho_{K}(u)u:u\in\mathbb{S}^{n-1}\\}.$

By (2.1), (2.2) and (2.3), the support function $h_{K}$ and the radial
function $\rho_{K}$ have the following relationship:

$h_{K}(x)=\max_{u\in\mathbb{S}^{n-1}}\langle u,x\rangle\rho_{K}(u),\quad
x\in\mathbb{S}^{n-1},$

and

$\rho_{K}(u)=\max_{x\in\mathbb{S}^{n-1}}\langle u,x\rangle/h_{K}(x),\quad
u\in\mathbb{S}^{n-1}.$

The definition of polar body, i.e.(1.2), shows that

(2.4) $\rho_{K}=1/h_{K^{*}},\quad h_{K}=1/\rho_{K^{*}}.$

From (2.4), it is clear that

(2.5) $K^{**}=K.$

Let $\Omega\subset\mathbb{S}^{n-1}$ be a closed set that is not contained in
any closed hemisphere of $\mathbb{S}^{n-1}$. And
$h,\rho:\Omega\rightarrow(0,\infty)$ are continuous functions. The Wulff shape
determined by $h$, is denoted by

$[h]=\bigcap_{x\in\Omega}\\{y\in\mathbb{R}^{n}:x\cdot y\leq h(x)\\},$

and the convex hull $\langle\rho\rangle$ generated by $\rho$, is denoted by

$\langle\rho\rangle=\text{conv}\\{\rho(u)u:u\in\Omega\\}.$

And a useful fact is that, see [24],

(2.6) $[h]^{*}=\langle 1/h\rangle.$

If $h_{K}$ is the support function of a convex body $K$, then

$[h_{K}]=K,$

and if $\rho_{K}$ is the radial function of a convex body $K$, then

(2.7) $\langle\rho_{K}\rangle=K.$

Assume $h_{t}:\Omega\rightarrow(0,\infty)$ is a continuous function defined
for $t\in(-\delta,\delta)$ by

(2.8) $\log h_{t}(x)=\log h(x)+tf(x)+o(t,x),$

where $f:\Omega\rightarrow\mathbb{R}$ is continuous, $\delta>0$ and
$o(t,\cdot):(-\delta,\delta)\times\mathbb{S}^{n-1}\rightarrow\mathbb{R}$ is
continuous and for $x\in\Omega$, $\lim_{t\rightarrow 0}\frac{o(t,x)}{t}=0$. We
shall write $[h_{t}]$ as $[h,f,t]$. And if $h$ is the support function of a
convex body $K$, write $[h_{t}]$ as $[K,f,t]$.

Suppose $\rho_{t}:\Omega\rightarrow(0,\infty)$ is a continuous function
defined for $t\in(-\delta,\delta)$ by

(2.9) $\log\rho_{t}(u)=\log\rho(u)+tg(u)+o(t,u),$

where $g:\Omega\rightarrow\mathbb{R}$ is continuous and
$o(t,\cdot):(-\delta,\delta)\times\mathbb{S}^{n-1}\rightarrow\mathbb{R}$ is
continuous and for $u\in\Omega$, $\lim_{t\rightarrow 0}\frac{o(t,u)}{t}=0$. We
shall write $\langle\rho_{t}\rangle$ as $\langle\rho,g,t\rangle$. And if
$\rho$ is the radial function of a convex body $K$, write
$\langle\rho_{t}\rangle$ as $\langle K,g,t\rangle$.

The $L_{p}$ Minkowski sum is the key role in the $L_{p}$ Brunn-Minkowski
theory. For fixed $p\in\mathbb{R}$, suppose $K$, $L\in\mathcal{K}^{n}_{0}$ and
$a$, $b\geq 0$, the $L_{p}$ Minkowski combination, $a\cdot K+_{p}b\cdot
L\in\mathcal{K}^{n}_{0}$, is defined by the Wulff shape

$a\cdot K+_{p}b\cdot L=[(ah_{K}^{p}+bh_{L}^{p})^{\frac{1}{p}}],\quad p\neq 0,$

and for $p=0$,

$a\cdot K+_{0}b\cdot L=[h_{K}^{a}h_{L}^{b}].$

The Wulff shape allows us to consider the case $a$ or $b$ is negative, with
strictly positive $ah_{K}^{p}+bh_{L}^{p}$. The $L_{p}$ harmonic combination,
$a\cdot K\hat{+}_{p}b\cdot L\in\mathcal{K}^{n}_{0}$, is defined by

$a\cdot K\hat{+}_{p}b\cdot L=(a\cdot K^{*}+_{p}b\cdot L^{*})^{*}.$

If $\mu$ is a fixed non-zero finite Borel measure on $\mathbb{S}^{n-1}$, then
we define

(2.10)
$||f:\mu||_{p}=\bigg{(}\frac{1}{|\mu|}\int_{\mathbb{S}^{n-1}}f^{p}d\mu\bigg{)}^{\frac{1}{p}},\quad
p\neq 0,$

and

(2.11) $||f:\mu||_{0}=\exp\bigg{(}\frac{1}{|\mu|}\int_{\mathbb{S}^{n-1}}\log
fd\mu\bigg{)},\quad\forall f\in C^{+}(\mathbb{S}^{n-1}).$

For any $x_{0}\in\mathbb{S}^{n-1}$ and $0<\delta<1$, $\omega_{\delta}(x_{0})$
and $\omega^{\prime}_{\delta}(x_{0})$ are defined by

(2.12) $\omega_{\delta}(x_{0})=\\{u\in\mathbb{S}^{n-1}:\langle
u,x_{0}\rangle\geq\delta\\},$ (2.13)
$\omega^{\prime}_{\delta}(x_{0})=\\{u\in\mathbb{S}^{n-1}:|\langle
u,x_{0}\rangle|\geq\delta\\}.$

It is obvious that

$\omega^{\prime}_{\delta}(x_{0})=\omega_{\delta}(x_{0})\cup\omega_{\delta}(-x_{0}).$

And $x_{0}^{\bot}$ denotes the hyperplane whose normal is $x_{0}$ and the
origin $0\in x_{0}^{\bot}$.

######  Definition 2.1.

Suppose $K$, $L\in\mathcal{K}^{n}_{0}$, their Hausdorff metric is given by

$d(K,L)=\max\\{\sup_{x\in K}dist(x,L),\sup_{y\in L}dist(K,y)\\}.$

where $dist(x,L)=\inf_{y\in L}dist(x,y)$ and $dist(x,y)$ is the distance of
$x$ and $y$ in $\mathbb{R}^{n}$. We say $K_{i}\rightarrow K_{0}$, which means
$d(K_{i},K_{0})\rightarrow 0$ as $i\rightarrow\infty$.

It is important to recall the following Lemma in [25].

######  Lemma 2.2.

Suppose $0<\delta<1$, $K_{i}$ is a sequence of convex bodies in
$\mathcal{K}^{n}_{0}$, and if for some $x_{0}\in\mathbb{S}^{n-1}$,

$\lim_{i\rightarrow\infty}h_{K_{i}}(x_{0})=0,$

then

$\lim_{i\rightarrow\infty}\rho_{K_{i}}(u)=0,\quad\forall
u\in\omega_{\delta}(x_{0}).$

##  3\. $L_{p}$ Gauss image problem

In this section, we review some of the standard facts on the radial Gauss map
$\alpha_{K}$ and reverse radial Gauss map $\alpha_{K}^{*}$.

Suppose $K\in\mathcal{K}^{n}_{0}$ and $x\in\mathbb{S}^{n-1}$, the supporting
hyperplane of $K$ in direction $x$ is given by

$H_{K}(x)=\\{y\in\mathbb{R}^{n}:\langle x,y\rangle=h_{K}(x)\\},$

and $x$ is called the normal vector of $K$ at $y$.

For $\sigma\subset\partial K$, the spherical image of $\sigma$,
$\boldsymbol{\nu}_{K}(\sigma):\partial K\rightarrow\mathbb{S}^{n-1}$, is
defined by

$\boldsymbol{\nu}_{K}(\sigma)=\\{x\in\mathbb{S}^{n-1}:y\in H_{K}(x)\text{ for
some }y\in\sigma\\}.$

Let $\sigma_{K}\subset\partial K$ be the set consisting of $y\in\partial K$,
for which the set $\boldsymbol{\nu}_{K}(\\{y\\})$ contains more than a single
element. Define the spherical image map

$\nu_{K}:\partial K\backslash\sigma_{K}\rightarrow\mathbb{S}^{n-1}$

such that $\nu_{K}(y)$ is the unique element of
$\boldsymbol{\nu}_{K}(\\{y\\})$.

For $\eta\subset\mathbb{S}^{n-1}$, the reverse spherical image of $\eta$,
y${}_{K}(\eta):\mathbb{S}^{n-1}\rightarrow\partial K$, is defined by

$\textbf{y}_{K}(\eta)=\\{y\in\partial K:y\in H_{K}(x)\text{ for some
}x\in\eta\\}.$

The set $\eta_{K}$ is made up of $x\in\mathbb{S}^{n-1}$, for which the set
$\textbf{y}_{K}(\\{x\\})$ contains more than a single element. Define the
reverse spherical image map

$y_{K}:\mathbb{S}^{n-1}\backslash\eta_{K}\rightarrow\partial K$

such that $y_{K}(x)$ is the unique element of $\textbf{y}_{K}(\\{x\\})$. It is
well known that $\mathcal{H}^{n-1}(\sigma_{K})=\mathcal{H}^{n-1}(\eta_{K})=0$
and $\nu_{K}$, $y_{K}$ are continuous functions, the details can be found in
[41].

Suppose $K\in\mathcal{K}^{n}_{0}$, the radial map of $K$,
$r_{K}:\mathbb{S}^{n-1}\rightarrow\partial K$, is defined by

$r_{K}(u)=\rho_{K}(u)u,$

its reverse map $r^{-1}_{K}:\partial K\rightarrow\mathbb{S}^{n-1}$ is given by

$r^{-1}_{K}(y)=\frac{y}{|y|}.$

With the above preparation, we can define the radial Gauss image and reverse
radial Gauss image. Specifically, let $\omega$ and $\eta$ be subsets of
$\mathbb{S}^{n-1}$, the radial Gauss image of $\omega$,
$\boldsymbol{\alpha}_{K}(\omega)$, is defined by

$\boldsymbol{\alpha}_{K}(\omega)=\\{x\in\mathbb{S}^{n-1}:\rho_{K}(u)u\in
H_{K}(x)\text{ for some }u\in\omega\\};$

and the reverse radial Gauss image of $\eta$,
$\boldsymbol{\alpha}^{\ast}_{K}(\eta)$, is defined by

$\boldsymbol{\alpha}^{\ast}_{K}(\eta)=\\{u\in\mathbb{S}^{n-1}:\rho_{K}(u)u\in
H_{K}(x)\text{ for some }x\in\eta\\}.$

Assume $K\in\mathcal{K}^{n}_{0}$, the radial Gauss map of $K$,
$\alpha_{K}:\mathbb{S}^{n-1}\backslash\omega_{K}\rightarrow\mathbb{S}^{n-1}$,
is given by

$\alpha_{K}=\nu_{K}(r_{K}),$

where $\omega_{K}=r^{-1}_{K}(\sigma_{K})$, and the reverse radial Gauss map of
$K$,
$\alpha^{*}_{K}:\mathbb{S}^{n-1}\backslash\eta_{K}\rightarrow\mathbb{S}^{n-1}$,
is given by

$\alpha^{*}_{K}=r^{-1}_{K}(y_{K}).$

It was shown in [24] that the reverse radial Gauss image of $K$ and the radial
Gauss image of $K^{*}$ are identical, that is

$\boldsymbol{\alpha}_{K^{\ast}}=\boldsymbol{\alpha}_{K}^{\ast}.$

And the definitions of $\boldsymbol{\alpha}_{K}$ and
$\boldsymbol{\alpha}_{K}^{*}$ yield that

$\boldsymbol{\alpha}_{tK}=\boldsymbol{\alpha}_{K},\quad\boldsymbol{\alpha}^{*}_{tK}=\boldsymbol{\alpha}^{*}_{K},\quad\forall
t>0.$

Recall the Gauss image measure $\lambda(K,\cdot)$ of $\lambda$ via $K$ is
defined by

$\lambda(K,\omega)=\lambda(\boldsymbol{\alpha}_{K}(\omega)).$

When $\lambda$ is a Borel measure which is absolutely continuous with respect
to the spherical Lebusgus measure, the Gauss image measure is a Borel measure.
The integral representation of $\lambda(K,\cdot)$ can be found in [5].

######  Lemma 3.1.

Assume $\lambda$ is a Borel measure which is absolutely continuous with
respect to spherical Lebesgue measure and $K\in\mathcal{K}^{n}_{0}$, then

(3.1)
$\int_{\mathbb{S}^{n-1}}f(u)d\lambda(K,u)=\int_{\mathbb{S}^{n-1}}f(\alpha^{\ast}_{K}(x))d\lambda(x),\quad\forall
f\in C(\mathbb{S}^{n-1}).$

###### Proof.

Note that for any $\omega\subset\mathbb{S}^{n-1}$ and
$x\in\mathbb{S}^{n-1}\backslash\omega_{K}$,

$\alpha_{K}^{*}(x)\in\omega\Leftrightarrow
x\in\boldsymbol{\alpha}_{K}(\omega),$

which implies that

(3.2)
$\chi_{\omega}(\alpha_{K}^{*}(x))=\chi_{\boldsymbol{\alpha}_{K}(\omega)}(x).$

We first show (3.1) holds for simple function

$\varphi=\sum_{i}c_{i}\chi_{\omega_{i}},$

where $c_{i}\in\mathbb{R}$ and $\chi_{\omega_{i}}$ is the characteristic
function of Borel subset $\omega_{i}\subset\mathbb{S}^{n-1}$.

Since $\lambda$ is absolutely continuous with respect to spherical Lebesgue
measure, (3.2) shows that

(3.3)
$\int_{\mathbb{S}^{n-1}}\chi_{\omega}(\alpha_{K}^{*}(x))d\lambda(x)=\int_{\mathbb{S}^{n-1}}\chi_{\alpha_{K}(\omega)}(x)d\lambda(x),$

then (1.6) and (3.3) mean

$\displaystyle\int_{\mathbb{S}^{n-1}}\varphi(u)d\lambda(K,u)$ $\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\sum_{i}c_{i}\chi_{\omega_{i}}(u)d\lambda(K,u)$
$\displaystyle=$ $\displaystyle\sum_{i}c_{i}\lambda(K,\omega_{i})$
$\displaystyle=$
$\displaystyle\sum_{i}c_{i}\lambda(\boldsymbol{\alpha}_{K}(\omega_{i}))$
$\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\sum_{i}c_{i}\chi_{\boldsymbol{\alpha}_{K}(\omega_{i})}(x)d\lambda(x)$
$\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\sum_{i}c_{i}\chi_{\omega}(\alpha_{K}^{*}(x))d\lambda(x)$
$\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\varphi(\alpha_{K}^{*}(x))d\lambda(x).$

Let $f:\mathbb{S}^{n-1}\rightarrow\mathbb{R}$ be a continuous function, then
there exists a sequence of simple functions $\\{\varphi_{k}\\}$ such that
$\varphi_{k}\rightarrow f$ as $k\rightarrow\infty$. By the dominated
convergence theorem, it holds

$\int_{\mathbb{S}^{n-1}}f(u)d\lambda(K,u)=\int_{\mathbb{S}^{n-1}}f(\alpha_{K}^{\ast}(x))d\lambda(x).$

This finishes the proof. ∎

Inspired by [25], we define the $L_{p}$ Gauss image measure
$\lambda_{p}(K,\cdot)$ of $K\in\mathcal{K}^{n}_{0}$: fixed $p\in\mathbb{R}$,
$\lambda_{p}(K,\cdot)$ is a Borel measure and satisfies

(3.4)
$\int_{\mathbb{S}^{n-1}}f(u)d\lambda_{p}(K,u)=\int_{\mathbb{S}^{n-1}}f(\alpha_{K}^{\ast}(x))\rho_{K}^{p}(\alpha_{K}^{\ast}(x))d\lambda(x),\quad\forall
f\in C(\mathbb{S}^{n-1}).$

By (3.1) and (3.4), it is easy to see

$d\lambda_{p}(K,\cdot)=\rho_{K}^{p}d\lambda(K,\cdot).$

It is worth to point out the Gauss image measure as a functional from
$\mathcal{K}^{n}_{0}$ to the space of Borel measures on $\mathbb{S}^{n-1}$ is
weakly convergent with respect to the Hausdorff metric, see Lemma 3.4 in [5].

######  Lemma 3.2.

Assume $\lambda$ is a Borel measure which is absolutely continuous with
respect to spherical Lebesgue measure, and
$K_{0},K_{1},\cdots\in\mathcal{K}^{n}_{0}$ such that $K_{i}\rightarrow K_{0}$
as $i\rightarrow\infty$, then
$\lambda(K_{i},\cdot)\rightharpoonup\lambda(K_{0},\cdot)$.

##  4\. Variational formulas for entropy of convex bodies

In this section, variational formulas for the general entropy of convex bodies
will be given. Recall the general entropy

$G(K)=-\int_{\mathbb{S}^{n-1}}\log h_{K}(x)d\lambda(x),$

and the dual general entropy, defined by

(4.1) $E(K)=\int_{\mathbb{S}^{n-1}}\log\rho_{K}(u)d\lambda(u),$

it is clear that for any $K\in\mathcal{K}^{n}_{0}$,

(4.2) $E(K^{*})=G(K).$

As will be shown, the following Lemma in [24] turns out to be a critical
property.

######  Lemma 4.1.

Let $\Omega\subset\mathbb{S}^{n-1}$ be a closed set that is not contained in
any closed hemisphere of $\mathbb{S}^{n-1}$. If $\rho_{t}$ is a logarithmic
family of convex hulls of $\langle\rho_{0},g,t\rangle$, then

$\lim_{t\rightarrow 0}\frac{\log h_{\langle\rho_{t}\rangle}(x)-\log
h_{\langle\rho_{0}\rangle}(x)}{t}=g(\alpha_{\langle\rho_{0}\rangle}^{*}(x)),\quad\forall
x\in\mathbb{S}^{n-1}\backslash\omega_{\langle\rho_{0}\rangle}.$

Furthermore, there exist $\delta>0$ and $M>0$, such that

$|\log h_{\langle\rho_{t}\rangle}(x)-\log h_{\langle\rho_{0}\rangle}(x)|\leq
M|t|,\quad\forall(x,t)\in\mathbb{S}^{n-1}\times(-\delta,\delta).$

It is sufficient to make the following Lemma together with Lemma 3.1 and Lemma
4.1.

######  Lemma 4.2.

Assume $\lambda$ is a Borel measure which is absolutely continuous with
respect to spherical Lebesgue measure. Let $K\in\mathcal{K}^{n}_{0}$ and
$f,g:\mathbb{S}^{n-1}\rightarrow\mathbb{R}$ be two continuous functions, if
$\rho_{t}$ is given by (2.9), then

(4.3)
$\frac{d}{dt}G(\langle\rho_{t}\rangle)\bigg{|}_{t=0}=-\int_{\mathbb{S}^{n-1}}g(u)d\lambda(K,u),$

and if $h_{t}$ is given by (2.8), then

(4.4)
$\frac{d}{dt}E([h_{t}])\bigg{|}_{t=0}=\int_{\mathbb{S}^{n-1}}f(x)d\lambda(K^{*},x).$

It remains to prove the variational formulas applying the Lemma 4.2 in this
section.

######  Lemma 4.3.

Assume $\lambda$ is a Borel measure which is absolutely continuous with
respect to spherical Lebesgue measure and $K,L\in\mathcal{K}^{n}_{0}$. Thus
for $p\neq 0$,

(4.5) $\frac{d}{dt}G(K\hat{+}_{p}t\cdot
L)\bigg{|}_{t=0}=\frac{1}{p}\int_{\mathbb{S}^{n-1}}\rho_{L}^{-p}(u)d\lambda_{p}(K,u),$

and for $p=0$,

(4.6) $\frac{d}{dt}G(K\hat{+}_{0}t\cdot
L)\bigg{|}_{t=0}=-\int_{\mathbb{S}^{n-1}}\log\rho_{L}(u)d\lambda(K,u).$

###### Proof.

For $p\neq 0$, let

$h_{t}=(h_{K}^{p}+th_{L}^{p})^{\frac{1}{p}},$

and choose $\delta>0$ such that

$\log h_{t}=\log h_{K}+\frac{1}{p}(\frac{h_{L}}{h_{K}})^{p}t+o_{p}(t,\cdot),$

where $o_{p}:(-\delta,\delta)\times\mathbb{S}^{n-1}\rightarrow\mathbb{R}$ is
continuous and satisfies

$\lim_{t\rightarrow 0}\frac{o_{p}(t,x)}{t}=0,\quad\forall
x\in\mathbb{S}^{n-1}.$

Choosing

$f=\frac{1}{p}(\frac{h_{L}}{h_{K}})^{p},$

we have

$K+_{p}t\cdot L=[h_{t}]=[K,f,t].$

Then (4.4) amounts to the fact that

$\displaystyle\frac{d}{dt}E(K+_{p}t\cdot L)\bigg{|}_{t=0}$ $\displaystyle=$
$\displaystyle\frac{1}{p}\int_{\mathbb{S}^{n-1}}(\frac{h_{L}}{h_{K}})^{p}(x)d\lambda(K^{*},x).$

Replace $K,L$ by $K^{*},L^{*}$ yields

(4.7) $\displaystyle\frac{d}{dt}E(K^{*}+_{p}t\cdot L^{*})\bigg{|}_{t=0}$
$\displaystyle=$
$\displaystyle\frac{1}{p}\int_{\mathbb{S}^{n-1}}(\frac{h_{L^{*}}}{h_{K^{*}}})^{p}(u)d\lambda(K^{**},u).$

Based on (2.4), (2.5) and (4.7), we can assert that

(4.8) $\displaystyle\frac{d}{dt}E(K^{*}+_{p}t\cdot L^{*})\bigg{|}_{t=0}$
$\displaystyle=$
$\displaystyle\frac{1}{p}\int_{\mathbb{S}^{n-1}}(\frac{\rho_{K}}{\rho_{L}})^{p}(u)d\lambda(K,u).$

Thus (4.5) can be obtained by (1.8), (4.2) and (4.8).

We now turn to the case $p=0$. Set $h_{t}=h_{K}h_{L}^{t}$, thus we get

$\log h_{t}=\log h_{K}+t\log h_{L}.$

Since the proof for the case $p=0$ is similar in spirit to the case $p\neq 0$,
we omit the detials here. ∎

##  5\. Existence of solutions to the $L_{p}$ Gauss image problem

For given Borel measures $\lambda$ and $\mu$, and $p\neq 0$, define the
functional
$\Phi_{\lambda,\mu,p}:C^{+}(\mathbb{S}^{n-1})\rightarrow\mathbb{R}$, for any
$f\in C^{+}(\mathbb{S}^{n-1})$,

$\displaystyle\Phi_{\lambda,\mu,p}(f)$ $\displaystyle=$
$\displaystyle-\frac{1}{|\lambda|}\int_{\mathbb{S}^{n-1}}\log h_{\langle
f\rangle}(x)d\lambda(x)-\frac{1}{p}\log(\frac{1}{|\mu|}\int_{\mathbb{S}^{n-1}}f^{-p}(u)d\mu(u))$
$\displaystyle=$ $\displaystyle G(\langle
f\rangle)/|\lambda|+\log||f:\mu||_{-p}.$

It is easy to check that $\Phi_{\lambda,\mu,p}(f)$ is homogeneous of degree 0,
that is

(5.2) $\Phi_{\lambda,\mu,p}(tf)=\Phi_{\lambda,\mu,p}(f),\quad\forall t>0,f\in
C^{+}(\mathbb{S}^{n-1})$

The maximization problem is:

(5.3) $\sup\\{\Phi_{\lambda,\mu,p}(f):f\in C^{+}(\mathbb{S}^{n-1})\\}.$

The following Lemma shows that the solution of maximization problem (5.3) must
be radial function of a convex body $K$.

######  Lemma 5.1.

Suppose $p\neq 0$, then a convex body $K\in\mathcal{K}^{n}_{0}$ is a solution
of the maximization problem

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{0}\\}$

if and only if $\rho_{K}$ is a solution of the maximization problem

$\sup\\{\Phi_{\lambda,\mu,p}(f):f\in C^{+}(\mathbb{S}^{n-1})\\}.$

###### Proof.

The convex hull is given by

$\langle f\rangle=\text{conv}\\{f(u)u:u\in\mathbb{S}^{n-1}\\},\quad\forall
f\in C^{+}(\mathbb{S}^{n-1}),$

then it is easily seen that

$\rho_{\langle f\rangle}\geq f,$

which implies that

(5.4) $||\rho_{\langle f\rangle}:\mu||_{-p}\geq||f:\mu||_{-p}.$

By (2.7), that is

$\langle\rho_{\langle f\rangle}\rangle=\langle f\rangle,$

hence

(5.5) $G(\langle\rho_{\langle f\rangle}\rangle)=G(\langle f\rangle).$

Applying (5.4) and (5.5) we conclude that

$\Phi_{\lambda,\mu,p}(f)\leq\Phi_{\lambda,\mu,p}(\rho_{\langle f\rangle}).$

∎

We have divided the proof into a sequence of Lemmas.

###  5.1. The proof of Theorem 1.2

In this subsection, we deal with the case $p>0$.

######  Lemma 5.2.

Under the assumptions of Theorem 1.2, there exists a convex body
$K_{0}\in\mathcal{K}^{n}_{0}$ such that

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{0}\\}=\Phi_{\lambda,\mu,p}(\rho_{K_{0}}).$

###### Proof.

Let

$\mathcal{K}=\\{K\in\mathcal{K}^{n}_{0}:\int_{\mathbb{S}^{n-1}}h_{K}^{p}d\mu=|\lambda|\\}.$

Define the function $\varphi:\mathbb{S}^{n-1}\rightarrow\mathbb{R}$, for
$x\in\mathbb{S}^{n-1}$,

$\varphi(x)=\int_{\mathbb{S}^{n-1}}(\langle x,u\rangle)_{+}^{p}d\mu(u).$

Assume $\varphi$ attains its minimum at some vectors $x_{\mu}$, thus

$\int_{\mathbb{S}^{n-1}}(\langle
x,u\rangle)_{+}^{p}d\mu(u)\geq\int_{\mathbb{S}^{n-1}}(\langle
x_{\mu},u\rangle)_{+}^{p}d\mu(u)>0,$

the strict inequality holds because $\mu$ is not concentrated in any closed
hemisphere of $\mathbb{S}^{n-1}$.

Now we claim that $\mathcal{K}$ is bounded. In fact, for any
$K\in\mathcal{K}$. Assume $\rho_{K}$ attains its maximum at some
$x_{K}\in\mathbb{S}^{n-1}$, by the definition of the support function, it is
clear that

$\rho_{K}(x_{K})(\langle x_{K},u\rangle)_{+}\leq h_{K}(u),\quad\forall
u\in\mathbb{S}^{n-1}.$

Then

$\rho^{p}_{K}(x_{K})\int_{\mathbb{S}^{n-1}}(\langle
x_{K},u\rangle)^{p}_{+}d\mu(u)\leq\int_{\mathbb{S}^{n-1}}h^{p}_{K}(u)d\mu(u)=|\lambda|,$

which implies that

$\rho_{K}(x_{K})\leq|\lambda|^{\frac{1}{p}}\bigg{(}\int_{\mathbb{S}^{n-1}}(\langle
x_{\mu},u\rangle)_{+}^{p}d\mu(u)\bigg{)}^{-\frac{1}{p}}=c(\lambda,\mu,p).$

Therefore, $\mathcal{K}$ is bounded.

By (5.2), $\Phi_{\lambda,\mu,p}(\rho_{K})$ is homogeneous of degree 0, it is
feasible to choose a maximizing sequence $K_{i}$ for
$\Phi_{\lambda,\mu,p}(\rho_{K})$ such that $K_{i}^{*}\in\mathcal{K}$. By
Blaskchke selection theorem, the sequence $K_{i}^{*}$ has a subsequence, still
denoted by $K_{i}^{*}$, such that $K_{i}^{*}\rightarrow K_{0}^{*}$ for some
$K_{0}^{*}$.

We prove $K_{0}^{*}\in\mathcal{K}^{n}_{0}$ by contradiction. Or we can assume
$K_{0}^{*}\subset u_{0}^{\bot}$ for some $u_{0}\in\mathbb{S}^{n-1}$, then

$\lim_{i\rightarrow\infty}h_{K_{i}^{*}}(u_{0})=h_{K_{0}^{*}}(u_{0})=0.$

By Lemma 2.2, there exists $0<\delta<1$ such that

(5.6) $\lim_{i\rightarrow\infty}\rho_{K_{i}^{*}}(x)\rightarrow 0,\quad\forall
x\in\omega_{\delta}(u_{0}).$

Then

$\displaystyle G(K_{i})$ $\displaystyle=$ $\displaystyle E(K_{i}^{*})$
$\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\log\rho_{K_{i}^{*}}(x)d\lambda(x)$
$\displaystyle\leq$
$\displaystyle\int_{\omega_{\delta}(u_{0})}\log\rho_{K_{i}^{*}}(x)d\lambda(x)+\int_{\mathbb{S}^{n-1}\backslash\omega_{\delta}(u_{0})}\log
c(\lambda,\mu,p)d\lambda(x)$ $\displaystyle\leq$
$\displaystyle\int_{\omega_{\delta}(u_{0})}\log\rho_{K_{i}^{*}}(x)d\lambda(x)+\log
c(\lambda,\mu,p)\lambda(\mathbb{S}^{n-1}\backslash\omega_{\delta}(u_{0})).$

From (5.6),(5.1) and the condition $\lambda(\omega_{\delta}(u_{0}))$ is
positive, it follows that

$G(K_{i})\rightarrow-\infty\quad\text{as}\quad i\rightarrow\infty,$

thus

$\Phi_{\lambda,\mu,p}(\rho_{K_{i}})\rightarrow-\infty\quad\text{as}\quad
i\rightarrow\infty.$

But it is easy to know that for $r=(|\lambda|/|\mu|)^{\frac{1}{p}}$,
$rB\in\mathcal{K}$, and

$\Phi_{\lambda,\mu,p}(K_{i})>\Phi_{\lambda,\mu,p}(rB)=\Phi_{\lambda,\mu,p}(B)=0,$

which is a contradiction. Then $K_{0}^{*}\in\mathcal{K}^{n}_{0}$, the proof is
complete. ∎

######  Lemma 5.3.

Under the assumptions of Theorem 1.2, if $K$ is a solution of the maximization
problem

(5.8) $\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{0}\\}$

under the restriction

(5.9) $\int_{\mathbb{S}^{n-1}}\rho_{K}^{-p}d\mu=|\lambda|,$

then

$\mu=\lambda_{p}(K,\cdot).$

###### Proof.

By Lemma 5.1 and $K$ is a maximizer of (5.8),

$\Phi_{\lambda,\mu,p}(\rho_{K})=\sup\\{\Phi_{\lambda,\mu,p}(\rho_{L}):L\in\mathcal{K}^{n}_{0}\\}=\sup\\{\Phi_{\lambda,\mu,p}(f):f\in
C^{+}(\mathbb{S}^{n-1})\\}.$

Define

(5.10) $\rho_{t}=\rho_{K}e^{tg},\quad\forall g\in C^{+}(\mathbb{S}^{n-1}),$

then $t=0$ must be the maximum point of $\Phi_{\lambda,\mu,p}(\rho_{t})$, that
is

(5.11) $\frac{d}{dt}\Phi_{\lambda,\mu,p}(\rho_{t})\bigg{|}_{t=0}=0.$

By (5.10),

$\log\rho_{t}=\log\rho_{K}+tg,$

then Lemma 4.2 shows that

(5.12)
$\frac{d}{dt}G(\langle\rho_{t}\rangle)\bigg{|}_{t=0}=-\int_{\mathbb{S}^{n-1}}g(u)d\lambda(K,u).$

For $|s|<1$, the inequality

(5.13) $|e^{s}-1-s|\leq es^{2}$

holds. Choosing $s=-ptg(u)$, (5.13) shows that for
$|t|<\frac{1}{|p|\max_{u\in\mathbb{S}^{n-1}}g(u)}$,

$|e^{-ptg(u)}-1+ptg(u)|\leq ep^{2}g^{2}(u)|t|^{2},\quad\forall
u\in\mathbb{S}^{n-1},$

which implies

$|\frac{e^{-tpg(u)}-1}{t}+pg(u)|\leq ep^{2}g^{2}(u)|t|,\quad\forall
u\in\mathbb{S}^{n-1}.$

Then

$\lim_{t\rightarrow
0}\frac{\rho_{t}^{-p}(u)-\rho_{0}^{-p}(u)}{t}=\lim_{t\rightarrow
0}\frac{e^{-tpg(u)}-1}{t}\rho_{K}^{-p}(u)=-pg(u)\rho_{K}^{-p}(u),\quad\forall
u\in\mathbb{S}^{n-1}.$

By (5.9), we get

$\displaystyle|\lambda|\frac{d}{dt}\log||\rho_{t}:\mu||_{-p}\bigg{|}_{t=0}$
$\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\rho_{K}^{-p}(u)d\mu(u)\cdot\frac{d}{dt}\log||\rho_{t}:\mu||_{-p}\bigg{|}_{t=0}$
$\displaystyle=$
$\displaystyle-\frac{1}{p}\int_{\mathbb{S}^{n-1}}\lim_{t\rightarrow
0}\frac{\rho_{t}^{-p}(u)-\rho_{0}^{-p}(u)}{t}d\mu(u)$ $\displaystyle=$
$\displaystyle\int_{\mathbb{S}^{n-1}}\rho_{K}^{-p}(u)g(u)d\mu(u).$

Therefore, (5.11), (5.12), (5.1) and the definition of $\Phi_{\lambda,\mu,p}$
show that

$\int_{\mathbb{S}^{n-1}}\rho_{K}^{-p}(u)g(u)d\mu(u)=\int_{\mathbb{S}^{n-1}}g(u)d\lambda(K,u).$

Thus $\rho_{K}(u)^{-p}d\mu(u)=d\lambda(K,u)$, which completes the proof in
view of (1.8). ∎

The proof of Theorem 1.2. By Lemma 5.2, there exists a convex body
$K_{0}\in\mathcal{K}^{n}_{0}$ such that

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{0}\\}=\Phi_{\lambda,\mu,p}(\rho_{K_{0}}).$

By Lemma 5.3, $K_{0}$ satisfies that

$\mu=\lambda_{p}(K_{0},\cdot).$

###  5.2. The proof of Theorem 1.3

This subsection is intended to provide a detailed proof of Theorem 1.3.

######  Lemma 5.4.

Under the assumptions of Theorem 1.3, there exists an origin-symmetric convex
body $K_{0}$ such that

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{e}\\}=\Phi_{\lambda,\mu,p}(\rho_{K_{0}}).$

###### Proof.

Let

$\mathcal{K}=\\{K\in\mathcal{K}^{n}_{e}:\int_{\mathbb{S}^{n-1}}\log
h_{K}(x)d\lambda(x)=0\\}.$

Since $\Phi_{\lambda,\mu,p}$ is homogeneous of degree 0, the maximization
problem is equivalent to

$\sup\\{\log||\rho_{K}:\mu||_{-p}:K\in\mathcal{K}\\}.$

Now we claim that $\mathcal{K}$ is bounded. In fact, for any
$K\in\mathcal{K}$. Assume $\rho_{K}$ attains its maximum at some
$u_{K}\in\mathbb{S}^{n-1}$, by the definition of the support function and
$K\in\mathcal{K}^{n}_{e}$, it is clear that

$\rho_{K}(u_{K})|\langle u_{K},x\rangle|\leq h_{K}(x),\quad\forall
x\in\mathbb{S}^{n-1},$

which implies

$\rho_{K}(u_{K})|\lambda|+\int_{\mathbb{S}^{n-1}}\log|\langle
u_{K},x\rangle|d\lambda(x)\leq\int_{\mathbb{S}^{n-1}}\log
h_{K}(x)d\lambda(x)=0.$

Then

$\rho_{K}(u_{K})\leq-|\lambda|^{-1}\int_{\mathbb{S}^{n-1}}\log|\langle
u_{K},x\rangle|d\lambda(x)=R.$

Therefore, $\mathcal{K}$ is bounded.

By (5.2), $\Phi_{\lambda,\mu,p}(\rho_{K})$ is homogeneous of degree 0, it is
feasible to choose a maximizing sequence $K_{i}$ for
$\Phi_{\lambda,\mu,p}(\rho_{K})$ such that $K_{i}\in\mathcal{K}$. By Blaskchke
selection theorem, the sequence $K_{i}$ has a subsequence, still denoted by
$K_{i}$, such that $K_{i}\rightarrow K_{0}$ for some $K_{0}$.

We prove $K_{0}\in\mathcal{K}^{n}_{e}$ by contradiction. Otherwise, assume
$K_{0}\subset x_{0}^{\bot}$ for some $x_{0}\in\mathbb{S}^{n-1}$, then

$\lim_{i\rightarrow\infty}h_{K_{i}}(x_{0})=h_{K_{0}}(x_{0})=0.$

By Lemma 2.2, there exists $0<\delta<1$ such that

$\lim_{i\rightarrow\infty}\rho_{K_{i}}(u)\rightarrow 0,\quad\forall
u\in\omega^{\prime}_{\delta}(x_{0}).$

Therefore,

$\displaystyle\int_{\mathbb{S}^{n-1}}\rho_{K_{i}}^{-p}(u)d\mu(u)$
$\displaystyle=$
$\displaystyle\int_{\omega^{\prime}_{\delta}(x_{0})}\rho_{K_{i}}^{-p}(u)d\mu(u)+\int_{\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta}(x_{0})}\rho_{K_{i}}^{-p}(u)d\mu(u)$
$\displaystyle\leq$
$\displaystyle\int_{\omega^{\prime}_{\delta}(x_{0})}\rho_{K_{i}}^{-p}(u)d\mu(u)+R^{-p}\mu(\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta}(x_{0})).$

Since $\mu$ vanishes on any great sub-sphere of $\mathbb{S}^{n-1}$, then
$\mu(\mathbb{S}^{n-1}\cap x_{0}^{\bot})=0$. Choose
$1>\delta_{1}>\delta_{2}>\cdots>\delta_{j}\rightarrow 0$, it is clear that

$\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta_{1}}(x_{0})\supset\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta_{2}}(x_{0})\supset\cdots,$

with

$\bigcap_{j=1}^{\infty}(\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta_{j}}(x_{0}))=\mathbb{S}^{n-1}\cap
x_{0}^{\bot}.$

Therefore

$\lim_{j\rightarrow\infty}\mu(\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta_{j}}(x_{0}))=\mu(\mathbb{S}^{n-1}\cap
x_{0}^{\bot})=0.$

For any given $\epsilon>0$, there exists a positive integer $j_{0}$, such that

$R^{-p}\mu(\mathbb{S}^{n-1}\backslash\omega^{\prime}_{\delta_{j_{0}}}(x_{0}))<\frac{\epsilon}{2}.$

Since $\rho_{K_{i}}\rightarrow 0$ uniformly on
$\omega^{\prime}_{\delta_{j_{0}}}(x_{0})$ and $\mu$ is a finite measure, there
exists a positive integer $N$, such that

$\int_{\omega^{\prime}_{\delta_{j_{0}}}(x_{0})}\rho_{K_{i}}^{-p}(u)d\mu(u)<\frac{\epsilon}{2},\quad\forall
i>N.$

Therefore,

$\int_{\mathbb{S}^{n-1}}\rho_{K_{i}}^{-p}(u)d\mu(u)\rightarrow 0\quad\text{ as
}\quad i\rightarrow\infty.$

So

$\Phi_{\lambda,\mu,p}(\rho_{K_{i}})=\log||\rho_{K_{i}}:\mu||_{-p}\rightarrow-\infty\quad\text{
as }\quad i\rightarrow\infty.$

But $K_{i}$ is a maximizing sequence for $\Phi_{\lambda,\mu,p}$, then for
sufficiently large $i$, one can see

$\Phi_{\lambda,\mu,p}(\rho_{K_{i}})>\Phi_{\lambda,\mu,p}(\rho_{B})=0.$

That is a contradiction. Then $K\in\mathcal{K}^{n}_{e}$, the proof is
complete. ∎

######  Lemma 5.5.

Under the assumptions of Theorem 1.3, if $K$ is a solution of the maximization
problem

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{e}\\}$

under the restriction

$\int_{\mathbb{S}^{n-1}}\rho_{K}^{-p}d\mu=|\lambda|,$

then

$\mu=\lambda_{p}(K,\cdot).$

###### Proof.

The proof of this Lemma is the same as that of Lemma 5.3. ∎

The proof of Theorem 1.3. By Lemma 5.4, there exists a convex body
$K_{0}\in\mathcal{K}^{n}_{e}$ such that

$\sup\\{\Phi_{\lambda,\mu,p}(\rho_{K}):K\in\mathcal{K}^{n}_{e}\\}=\Phi_{\lambda,\mu,p}(\rho_{K_{0}}).$

By Lemma 5.5, $K_{0}$ satisfies that

$\mu=\lambda_{p}(K_{0},\cdot).$

## References

  * [1] A. Aleksandrov, _Existence and uniqueness of a convex surface with a given integral curvature_ , C. R. (Dokl.) Acad. Sci. URSS (NS) 35 (1942), 131-134.
  * [2] , _Convex Polyhedra_ , Springer Monographs in Mathematics. Springer, Berlin (2005).
  * [3] J. Bertrand, _Prescription of Gauss curvature using optimal mass transport_ , Geom. Dedicata 183 (2016), 81-99.
  * [4] G. Bian, K. Böröczky and A. Colesanti, _The Orlicz version of the $L_{p}$ Minkowski problem for $-n<p<0$_, Adv. in Appl. Math., 111 (2019), 101937.
  * [5] K. Böröczky, E. Lutwak, D. Yang, G. Zhang and Y. Zhao, _The Gauss image problem_ , Communications on Pure and Applied Mathematics, Vol. LXXIII, (2020), 1406–1452.
  * [6] K. Böröczky and F. Fodor, _The $L_{p}$ dual Minkowski problem for $p>1$ and $q>0$_, J. Differential Equations, 266 (2019), 7980–8033.
  * [7] K. Böröczky, M. Henk and H. Pollehn, _Subspace concentration of dual curvature measures of symmetric convex bodies_ , J. Differential Geom., 109 (2018), 411–429.
  * [8] K. Böröczky, E. Lutwak, D. Yang and G. Zhang, _The logarithmic Minkowski problem_ , J. Amer. Math. Soc., 26 (2013), 831–852.
  * [9] C. Chen, Y. Huang and Y. Zhao, _Smooth solutions to the $L_{p}$ dual Minkowski problem_, Math. Ann., 373 (2019), 953–976.
  * [10] H. Chen, S. Chen and Q. Li, _Variations of a class of Monge-Ampere type functionals and their applications_.  Accepted by Anal. PDE.
  * [11] S. Chen, Q. Li and G. Zhu, _The logarithmic Minkowski problem for non-symmetric measures_ , Trans. Amer. Math. Soc., 371 (2019), 2623–2641.
  * [12] L. Chen, Y. Liu, J. Lu and N. Xiang, _Existence of smooth even solutions to the dual Orlicz-Minkowski problem_ , arXiv:2005.02639.
  * [13] L. Chen, Q. Tu, D. Wu and N. Xiang, _Anisotropic Gauss curvature flows and their associated Dual Orlicz-Minkowski problems_ , to appear in Proceedings of the Royal Society of Edinburgh Section A: Mathematics.
  * [14] L. Chen, D. Wu and N. Xiang, _Smooth solutions to the Gauss image problem_ , arXiv:2012.11367.
  * [15] K. Chou and X. Wang, _A logarithmic Gauss curvature flow and the Minkowski problem_ , Ann. Inst. H. Poincaré Anal. Non Linéaire, 17 (2000), 733–751.
  * [16] , _The $L_{p}$-Minkowski problem and the Minkowski problem in centroaffine geometry_, Adv. Math., 205 (2006), 33–83.
  * [17] Y. Feng and B. He, _The Orlicz Aleksandrov problem for Orlicz integral curvature_ , Int. Math. Res. Notices, 7 (2021), 5492–5519.
  * [18] R. Gardner, D. Hug, W. Weil, S. Xing and D. Ye, _General volumes in the Orlicz-Brunn-Minkowski theory and a related Minkowski problem I_ , Calc. Var. Partial Differential Equations, 58 (2019), Paper No. 12, 35\.
  * [19] R. Gardner, D. Hug, S. Xing and D. Ye, _General volumes in the Orlicz-Brunn-Minkowski theory and a related Minkowski problem II_ , Calc. Var. Partial Differential Equations, 59 (2020), Paper No. 15, 33.
  * [20] C. Haberl, E. Lutwak, D. Yang and G. Zhang, _The even Orlicz Minkowski problem_ , Adv. Math., 224 (2010), 2485–2510.
  * [21] M. Henk and H. Pollehn, _Necessary subspace concentration conditions for the even dual Minkowski problem_ , Adv. Math., 323 (2018), 114–141.
  * [22] Q. Huang and B. He, _On the Orlicz Minkowski problem for polytopes_ , Discrete Comput. Geom., 48 (2012), 281–297.
  * [23] Y. Huang and Y. Jiang, _Variational characterization for the planar dual Minkowski problem_ , J. Funct. Anal., 277 (2019), 2209–2236.
  * [24] Y. Huang, E. Lutwak, D. Yang and G. Zhang, _Geometric measures in the dual Brunn-Minkowski theory and their associated Minkowski problems_ , Acta Math., 216 (2016), 325–388.
  * [25] , _The $L_{p}$-Aleksandrov problem for $L_{p}$-integral curvature_, J. Differential Geom., 110 (2018), 1–29.
  * [26] Y. Huang and Y. Zhao, _On the $L_{p}$ dual Minkowski problem_, Adv. Math., 332 (2018), 57–84.
  * [27] D. Hug, E. Lutwak, D. Yang and G. Zhang, _On the $L_{p}$ Minkowski problem for polytopes_, Discrete Comput. Geom., 33 (2005), 699–715.
  * [28] H. Jian and J. Lu, _Existence of solutions to the Orlicz-Minkowski problem_ , Adv. Math., 344 (2019), 262–288.
  * [29] H. Jian, J. Lu and X. Wang, _A priori estimates and existence of solutions to the prescribed centroaffine curvature problem_ , J. Funct. Anal., 274 (2018), 826–862.
  * [30] H. Jian, J. Lu and G. Zhu, _Mirror symmetric solutions to the centro-affine Minkowski problem_ , Calc. Var. Partial Differential Equations, 55 (2016), Paper No. 41.
  * [31] Q. Li, J. Liu and J. Lu, _Non-uniqueness of solutions to the $L_{p}$ dual Minkowski problem_.  Preprint.
  * [32] Q. Li, W. Sheng and X. Wang, _Flow by Gauss curvature to the Aleksandrov and dual Minkowski problems_ , J. Eur. Math. Soc. (JEMS), 22 (2020), 893–923.
  * [33] Y. Liu and J. Lu, _A flow method for the dual Orlicz-Minkowski problem_ , Trans. Amer. Math. Soc., 373 (2020), 5833–5853.
  * [34] J. Lu, _Nonexistence of maximizers for the functional of the centroaffine Minkowski problem_ , Sci. China Math., 61 (2018), 511–516.
  * [35] , _A remark on rotationally symmetric solutions to the centroaffine Minkowski problem_ , J. Differential Equations, 266 (2019), 4394–4431.
  * [36] J. Lu and X. Wang, _Rotationally symmetric solutions to the $L_{p}$-Minkowski problem_, J. Differential Equations, 254 (2013), 983–1005.
  * [37] E. Lutwak, _The Brunn-Minkowski-Firey theory. I. Mixed volumes and the Minkowski problem_ , J. Differential Geom., 38 (1993), 131–150.
  * [38] E. Lutwak, D. Yang and G. Zhang, _On the $L_{p}$-Minkowski problem_, Trans. Amer. Math. Soc., 356 (2004), 4359–4370.
  * [39] , _$L_{p}$ dual curvature measures_, Adv. Math., 329 (2018), 85-132.
  * [40] A. Stancu, _The discrete planar $L_{0}$-Minkowski problem_, Adv. Math., 167 (2002), 160–174.
  * [41] R. Schneider,_Convex bodies: the Brunn-Minkowski theory. Second expanded edition. Encyclopedia of Mathematics and Its Applications_ , 151. Cambridge University Press, Cambridge, 2014\.
  * [42] Y. Zhao, _The dual Minkowski problem for negative indices_ , Calc. Var. Partial Differential Equations, 56 (2017), Paper No. 18.
  * [43] , _Existence of solutions to the even dual Minkowski problem_ , J. Differential Geom., 110 (2018), 543–572.
  * [44] G. Zhu, _The logarithmic Minkowski problem for polytopes_ , Adv. Math., 262 (2014), 909–931.
  * [45] , _The centro-affine Minkowski problem for polytopes_ , J. Differential Geom., 101 (2015), 159–174.