corrected wording

Author: AdrienTaylor

PEPit/functions/smooth_convex_function.py

@@ -51,5 +51,5 @@ def __init__(self,
         if self.L == np.inf:
             print("\033[96m(PEPit) The class of smooth convex functions is necessarily differentiable.\n"
                   "To instantiate a convex function, please avoid using the class SmoothConvexFunction with \n"
-                  "L == infinity. Instead, please use the class ConvexFunction that allows to compute several \n"
-                  "subgradients at the same point each time one is required.\033[0m")
+                  "L == np.inf. Instead, please use the class ConvexFunction (which accounts for the fact \n"
+                  "that there might be several subgradients at the same point).\033[0m")

PEPit/functions/smooth_function.py

@@ -55,8 +55,8 @@ def __init__(self,
         self.L = L
 
         if self.L == np.inf:
-            print("\033[96m(PEPit) The class of smooth functions is necessarily differentiable. \n"
-                  "When setting L to infinity, you remove all the other constraints on the function.\033[0m")
+            print("\033[96m(PEPit) The class of L-smooth functions with L == np.inf implies no constraint: \n"
+                  "it contains all differentiable functions. This might imply issues in your code.\033[0m")
 
     def add_class_constraints(self):
         """

PEPit/functions/smooth_strongly_convex_function.py

@@ -61,8 +61,8 @@ def __init__(self,
         if self.L == np.inf:
             print("\033[96m(PEPit) The class of smooth strongly convex functions is necessarily differentiable.\n"
                   "To instantiate a strongly convex function, please avoid using the class SmoothStronglyConvexFunction\n"
-                  "with L == infinity. Instead, please use the class StronglyConvexFunction that allows to compute \n"
-                  "several subgradients at the same point each time one is required.\033[0m")
+                  "with L == np.inf. Instead, please use the class StronglyConvexFunction (which accounts for the fact\n"
+                  "that there might be several subgradients at the same point).\033[0m")
 
     def add_class_constraints(self):
         """

PEPit/operators/cocoercive.py

@@ -8,7 +8,7 @@ class CocoerciveOperator(Function):
     implementing the interpolation constraints of the class of cocoercive (and maximally monotone) operators.
 
     Note:
-        Operators'values can be requested through `gradient` and `function values` should not be used.
+        Operator values can be requested through `gradient` and `function values` should not be used.
 
     Attributes:
         beta (float): cocoercivity parameter
@@ -60,8 +60,8 @@ def __init__(self,
         if self.beta == 0:
             print("\033[96m(PEPit) The class of cocoercive operators is necessarily continuous. \n"
                   "To instantiate a monotone opetator, please avoid using the class CocoerciveOperator\n"
-                  "with beta == 0. Instead, please use the class Monotone that allows to compute \n"
-                  "several values of the operator at the same point each time one is required.\033[0m")
+                  "with beta == 0. Instead, please use the class Monotone (which accounts for the fact \n"
+                  "that the image of the operator at certain points might not be a singleton).\033[0m")
 
     def add_class_constraints(self):
         """

PEPit/operators/lipschitz.py

@@ -8,7 +8,7 @@ class LipschitzOperator(Function):
     implementing the interpolation constraints of the class of Lipschitz continuous operators.
 
     Note:
-        Operators'values can be requested through `gradient` and `function values` should not be used.
+        Operator values can be requested through `gradient` and `function values` should not be used.
 
     Attributes:
         L (float) Lipschitz parameter
@@ -76,8 +76,8 @@ def __init__(self,
         self.L = L
 
         if self.L == np.inf:
-            print("\033[96m(PEPit) The class of Lipschitz operators is necessarily continuous. \n"
-                  "When setting L to infinity, you remove all the other constraints on the operator.\033[0m")
+            print("\033[96m(PEPit) The class of L-Lipschitz operators with L == np.inf implies no constraint: \n"
+                  "it contains all multi-valued mappings. This might imply issues in your code.\033[0m")
 
     def add_class_constraints(self):
         """

PEPit/operators/lipschitz_strongly_monotone.py

@@ -9,7 +9,7 @@ class LipschitzStronglyMonotoneOperator(Function):
     for the class of Lipschitz continuous strongly monotone (and maximally monotone) operators.
 
     Note:
-        Operators'values can be requested through `gradient` and `function values` should not be used.
+        Operator values can be requested through `gradient` and `function values` should not be used.
 
     Warning:
         Lipschitz strongly monotone operators do not enjoy known interpolation conditions. The conditions implemented
@@ -70,9 +70,9 @@ def __init__(self,
 
         if self.L == np.inf:
             print("\033[96m(PEPit) The class of Lipschitz strongly monotone operators is necessarily continuous.\n"
-                  "To instantiate an operator, please avoid using the class LipschitzStronglyMonotoneOperator with L == infinity.\n"
-                  " Instead, please use the class StronglyMonotoneOperator that allows to compute several"
-                  "subgradients at the same point each time one is required.\033[0m")
+                  "To instantiate an operator, please avoid using the class LipschitzStronglyMonotoneOperator with\n"
+                  " L == np.inf. Instead, please use the class StronglyMonotoneOperator (which accounts for the fact\n"
+                  "that the image of the operator at certain points might not be a singleton).\033[0m")
 
     def add_class_constraints(self):
         """

PEPit/operators/monotone.py

@@ -7,7 +7,7 @@ class MonotoneOperator(Function):
     implementing interpolation constraints for the class of maximally monotone operators.
 
     Note:
-        Operators'values can be requested through `gradient` and `function values` should not be used.
+        Operator values can be requested through `gradient` and `function values` should not be used.
 
     General maximally monotone operators are not characterized by any parameter, hence can be instantiated as
 

PEPit/operators/strongly_monotone.py

@@ -8,7 +8,7 @@ class StronglyMonotoneOperator(Function):
     (maximally monotone) operators.
 
     Note:
-        Operators'values can be requested through `gradient` and `function values` should not be used.
+        Operator values can be requested through `gradient` and `function values` should not be used.
 
     Attributes:
         mu (float): strong monotonicity parameter

docs/source/quickstart.rst

@@ -73,12 +73,13 @@ From now, you can declare functions thanks to the `declare_function` method.
     To enforce the same subgradient to be returned each time one is required,
     we introduced the attribute `reuse_gradient` in the `Function` class.
     Some classes of functions contain only differentiable functions (e.g. smooth convex function).
-    In those, the `reuse_gradient` attribute is per default set to True.
+    In those, the `reuse_gradient` attribute is set to True by default.
 
     When the same subgradient is used several times in the same code and when it is difficult to
-    to keep track on it (through proximal calls for instance), it may be useful to set this parameter
+    to keep track of it (through proximal calls for instance), it may be useful to set this parameter
     to True even if the function is not differentiable. This helps reducing the number of constraints,
-    and improve the accuracy of the worst-case. See for instance the code for `improved interior method
+    and improve the accuracy of the underlying semidefinite program. See for instance the code for
+    `improved interior method 
     <https://pepit.readthedocs.io/en/latest/examples/b.html#improved-interior-method>`_ or
     `no Lips in Bregman divergence
     <https://pepit.readthedocs.io/en/latest/examples/b.html#no-lips-in-bregman-divergence>`_.
@@ -153,10 +154,10 @@ Finally, you can ask PEPit to solve the system for you and return the worst-case
     pepit_tau = problem.solve()
 
 .. warning::
-    Performance estimation problems consists in reformulating the problem as an optimization problem, convex in a Gram
-    matrix G, and in function values F. The dimension of G is directly related to the number of points at which
-    the gradients are evaluated, and the differentiability of the function.
-
+    Performance estimation problems consist in reformulating the problem of finding a worst-case scenario as a semidefinite
+    program (SDP). The dimension of the corresponding SDP is directly related to the number of function and gradient evaluations
+    in a given code.
+    
     We encourage the users to perform as few function and subgradient evaluations as possible, as the size of the
     corresponding SDP grows with the number of subgradient/function evaluations at different points.
 
@@ -213,26 +214,34 @@ Then, after solving the system, you can require its associated dual variable val
 Output pdf
 ~~~~~~~~~~
 
-In a latter release, we will provide an option to output a pdf file summarizing all those pieces of information.
+In a later release, we will provide an option to output a pdf file summarizing all those pieces of information.
 
-Simplify proofs
-^^^^^^^^^^^^^^^
+Simpler worst-case scenarios
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Sometimes, there are several solutions to the PEP problem.
-In order to simplify the proof, one would prefer a low dimension solution.
-To this end, we provide an **heuristic** based on the trace to reduce the dimension of the provided solution.
+For obtaining simpler worst-case scenarios, one would prefer a low dimension solutions to the SDP.
+To this end, we provide **heuristics** based on the trace norm or log det minimization for reducing
+the dimension of the numerical solution to the SDP.
 
-You can use it  by specifying
+You can use the trace heuristic by specifying
 
 .. code-block::
 
     problem.solve(dimension_reduction_heuristic="trace")
+    
+You can use the n iteration of the log det heuristic by specifying "logdetn". For example, for
+using 5 iterations of the logdet heuristic:
+
+.. code-block::
+
+    problem.solve(dimension_reduction_heuristic="logdet5")
 
 
 Finding Lyapunov
 ^^^^^^^^^^^^^^^^
 
-In a latter release, we will provide tools to help finding good Lyapunov functions to study a given method.
+In a later release, we will provide tools to help finding good Lyapunov functions to study a given method.
 
 This tool will be based on the very recent work [7].