fact stringlengths 5 7.52k | type stringclasses 9 values | library stringclasses 2 values | imports listlengths 0 15 | filename stringclasses 121 values | symbolic_name stringlengths 1 53 | docstring stringlengths 6 446 ⌀ |
|---|---|---|---|---|---|---|
addCommConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : 0 < x hx : x + (1 + x) ≤ 1 time_cmd equivalence addCommConstrRed/addCommConstrAuto : addCommConstr := by pre_dcp #print addCommConstrAuto -- add_assoc (obj) -- NOTE: This uses one_mul-rev because 2 * x is preferred over x + x. | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addCommConstr | null |
addAssocObj := optimization (x : ℝ) minimize (x + (x + 1) : ℝ) subject to h : 0 ≤ x time_cmd equivalence addAssocObjRed/addAssocObjAuto : addAssocObj := by pre_dcp #print addAssocObjAuto -- add_assoc (constr) -- NOTE: This uses one_mul-rev because 2 * x is preferred over x + x. | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addAssocObj | null |
addAssocConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : x + (x + 1) ≤ 1 time_cmd equivalence addAssocConstrRed/addAssocConstrAuto : addAssocConstr := by pre_dcp #print addAssocConstrAuto -- sub_self (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addAssocConstr | null |
subSelfObj := optimization (x : ℝ) minimize (x - x : ℝ) subject to h : 0 ≤ x time_cmd equivalence subSelfObjRed/subSelfObjAuto : subSelfObj := by pre_dcp #print subSelfObjAuto -- sub_self (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subSelfObj | null |
subSelfConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to h : y ≤ x - x time_cmd equivalence subSelfConstrRed/subSelfConstrAuto : subSelfConstr := by pre_dcp #print subSelfConstrAuto -- one_mul (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subSelfConstr | null |
oneMulObj := optimization (x : ℝ) minimize (1 * x : ℝ) subject to h : 0 ≤ x time_cmd equivalence oneMulObjRed/oneMulObjAuto : oneMulObj := by pre_dcp #print oneMulObjAuto -- one_mul (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneMulObj | null |
oneMulConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : 0 ≤ 1 * x time_cmd equivalence oneMulConstrRed/oneMulConstrAuto : oneMulConstr := by pre_dcp #print oneMulConstrAuto -- one_mul-rev (obj) -- NOTE: This uses one_mul-rev because 2 * x is preferred over x + x. | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneMulConstr | null |
oneMulRevObj := optimization (x : ℝ) minimize (x + x : ℝ) subject to h : 0 ≤ x time_cmd equivalence oneMulRevObjRed/oneMulRevObjAuto : oneMulRevObj := by pre_dcp #print oneMulRevObjAuto -- one_mul-rev (constr) -- NOTE: This uses one_mul-rev because 2 * x is preferred over x + x. | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneMulRevObj | null |
oneMulRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : 0 ≤ x + x time_cmd equivalence oneMulRevConstrRed/oneMulRevConstrAuto : oneMulRevConstr := by pre_dcp #print oneMulRevConstrAuto -- mul_zero (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneMulRevConstr | null |
mulZeroObj := optimization (x : ℝ) minimize (x * 0 : ℝ) subject to h : 0 ≤ x time_cmd equivalence mulZeroObjRed/mulZeroObjAuto : mulZeroObj := by pre_dcp #print mulZeroObjAuto -- mul_zero (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulZeroObj | null |
mulZeroConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to h : y ≤ x * 0 time_cmd equivalence mulZeroConstrRed/mulZeroConstrAuto : mulZeroConstr := by pre_dcp #print mulZeroConstrAuto -- mul_comm (obj) -- NOTE: Empty domain here. Why? | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulZeroConstr | null |
mulCommObj := optimization (x y : ℝ) minimize (x * (y * (1 / x)) : ℝ) subject to hx : 0 < x time_cmd equivalence mulCommObjRed/mulCommObjAuto : mulCommObj := by pre_dcp #print mulCommObjAuto -- mul_comm (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulCommObj | null |
mulCommConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : x * (y * (1 / x)) ≤ 1 time_cmd equivalence mulCommConstrRed/mulCommConstrAuto : mulCommConstr := by pre_dcp #print mulCommConstrAuto -- mul_assoc (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulCommConstr | null |
mulAssocObj := optimization (x : ℝ) minimize (sqrt x * (sqrt x * 2) : ℝ) subject to hx : 0 < x time_cmd equivalence mulAssocObjRed/mulAssocObjAuto : mulAssocObj := by pre_dcp #print mulAssocObjAuto -- mul_assoc (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAssocObj | null |
mulAssocConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : sqrt x * (sqrt x * 2) ≤ 1 time_cmd equivalence mulAssocConstrRed/mulAssocConstrAuto : mulAssocConstr := by pre_dcp #print mulAssocConstrAuto -- sub_eq_add_neg (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAssocConstr | null |
subEqAddNegObj := optimization (x y : ℝ) minimize (x - (-y) : ℝ) subject to h : 0 ≤ x time_cmd equivalence subEqAddNegObjRed/subEqAddNegObjAuto : subEqAddNegObj := by pre_dcp #print subEqAddNegObjAuto -- sub_eq_add_neg (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subEqAddNegObj | null |
subEqAddNegConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to h : y ≤ x - (-x) time_cmd equivalence subEqAddNegConstrRed/subEqAddNegConstrAuto : subEqAddNegConstr := by pre_dcp #print subEqAddNegConstrAuto -- sub_eq_add_neg-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subEqAddNegConstr | null |
subEqAddNegRevObj := optimization (x y : ℝ) minimize (x + (-y) : ℝ) subject to h : 0 ≤ x time_cmd equivalence subEqAddNegRevObjRed/subEqAddNegRevObjAuto : subEqAddNegRevObj := by pre_dcp #print subEqAddNegRevObjAuto -- sub_eq_add_neg-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subEqAddNegRevObj | null |
subEqAddNegRevConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to h : y ≤ x + (-x) time_cmd equivalence subEqAddNegRevConstrRed/subEqAddNegRevConstrAuto : subEqAddNegRevConstr := by pre_dcp #print subEqAddNegRevConstrAuto -- add_sub (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | subEqAddNegRevConstr | null |
addSubObj := optimization (x y : ℝ) minimize (x + (x - y) : ℝ) subject to h : 0 ≤ x time_cmd equivalence addSubObjRed/addSubObjAuto : addSubObj := by pre_dcp #print addSubObjAuto -- add_sub (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addSubObj | null |
addSubConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to h1 : 0 ≤ x h2 : x + (x - y) ≤ 1 time_cmd equivalence addSubConstrRed/addSubConstrAuto : addSubConstr := by pre_dcp #print addSubConstrAuto -- add_sub-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addSubConstr | null |
addSubRevObj := optimization (x : ℝ) minimize ((1 + x) - x : ℝ) subject to h : 0 ≤ x time_cmd equivalence addSubRevObjRed/addSubRevObjAuto : addSubRevObj := by pre_dcp #print addSubRevObjAuto -- add_sub-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addSubRevObj | null |
addSubRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h1 : 0 ≤ x h2 : (1 + x) - x ≤ 1 time_cmd equivalence addSubRevConstrRed/addSubRevConstrAuto : addSubRevConstr := by pre_dcp #print addSubRevConstrAuto -- add_mul (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addSubRevConstr | null |
addMulObj := optimization (x y : ℝ) minimize ((-1 + sqrt x) * sqrt x : ℝ) subject to hx : 0 < x time_cmd equivalence addMulObjRed/addMulObjAuto : addMulObj := by pre_dcp #print addMulObjAuto -- add_mul (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addMulObj | null |
addMulConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (-1 + sqrt x) * sqrt x ≤ 1 time_cmd equivalence addMulConstrRed/addMulConstrAuto : addMulConstr := by pre_dcp #print addMulConstrAuto -- add_mul-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addMulConstr | null |
addMulRevObj := optimization (x : ℝ) minimize (2 * x + 3 * x : ℝ) subject to hx : 0 ≤ x time_cmd equivalence addMulRevObjRed/addMulRevObjAuto : addMulRevObj := by pre_dcp #print addMulRevObjAuto -- add_mul-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addMulRevObj | null |
addMulRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 ≤ x h : 2 * x + 3 * x ≤ 1 time_cmd equivalence addMulRevConstrRed/addMulRevConstrAuto : addMulRevConstr := by pre_dcp #print addMulRevConstrAuto -- mul_add (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addMulRevConstr | null |
mulAddObj := optimization (x : ℝ) minimize (sqrt x * (-1 + sqrt x) : ℝ) subject to hx : 0 < x time_cmd equivalence mulAddObjRed/mulAddObjAuto : mulAddObj := by pre_dcp #print mulAddObjAuto -- mul_add (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAddObj | null |
mulAddConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : sqrt x * (-1 + sqrt x) ≤ 1 time_cmd equivalence mulAddConstrRed/mulAddConstrAuto : mulAddConstr := by pre_dcp #print mulAddConstrAuto -- mul_add-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAddConstr | null |
mulAddRevObj := optimization (x : ℝ) minimize (x * 2 + x * 3 : ℝ) subject to hx : 0 ≤ x time_cmd equivalence mulAddRevObjRed/mulAddRevObjAuto : mulAddRevObj := by pre_dcp #print mulAddRevObjAuto -- mul_add-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAddRevObj | null |
mulAddRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 ≤ x h : x * 2 + x * 3 ≤ 1 time_cmd equivalence mulAddRevConstrRed/mulAddRevConstrAuto : mulAddRevConstr := by pre_dcp #print mulAddRevConstrAuto -- mul_sub (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulAddRevConstr | null |
mulSubObj := optimization (x : ℝ) minimize (sqrt x * (sqrt x - 1) : ℝ) subject to hx : 0 < x time_cmd equivalence mulSubObjRed/mulSubObjAuto : mulSubObj := by pre_dcp #print mulSubObjAuto -- mul_sub (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulSubObj | null |
mulSubConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : sqrt x * (sqrt x - 1) ≤ 1 time_cmd equivalence mulSubConstrRed/mulSubConstrAuto : mulSubConstr := by pre_dcp #print mulSubConstrAuto -- mul_sub-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulSubConstr | null |
mulSubRevObj := optimization (x : ℝ) minimize (x * 2 - x * 3 : ℝ) subject to hx : 0 ≤ x time_cmd equivalence mulSubRevObjRed/mulSubRevObjAuto : mulSubRevObj := by pre_dcp #print mulSubRevObjAuto -- mul_sub-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulSubRevObj | null |
mulSubRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 ≤ x h : x * 2 - x * 3 ≤ 1 time_cmd equivalence mulSubRevConstrRed/mulSubRevConstrAuto : mulSubRevConstr := by pre_dcp #print mulSubRevConstrAuto -- add_div (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulSubRevConstr | null |
addDivObj := optimization (x y : ℝ) minimize ((exp x + 1) / (exp y) : ℝ) subject to hx : 0 ≤ x time_cmd equivalence addDivObjRed/addDivObjAuto : addDivObj := by pre_dcp #print addDivObjAuto -- add_div (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addDivObj | null |
addDivConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 ≤ x hy : 0 < y h : (exp x + 1) / (exp y) ≤ 1 time_cmd equivalence addDivConstrRed/addDivConstrAuto : addDivConstr := by pre_dcp #print addDivConstrAuto -- add_div-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addDivConstr | null |
addDivRevObj := optimization (x : ℝ) minimize ((x / 2) + ((-x) / 2) : ℝ) subject to hx : 0 < x time_cmd equivalence addDivRevObjRed/addDivRevObjAuto : addDivRevObj := by pre_dcp #print addDivRevObjAuto -- add_div-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addDivRevObj | null |
addDivRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : (x / 2) + ((-x) / 2) ≤ x time_cmd equivalence addDivRevConstrRed/addDivRevConstrAuto : addDivRevConstr := by pre_dcp #print addDivRevConstrAuto -- mul_div (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | addDivRevConstr | null |
mulDivObj := optimization (x y : ℝ) minimize ((sqrt x) * (sqrt x / 2) : ℝ) subject to hx : 0 < x time_cmd equivalence mulDivObjRed/mulDivObjAuto : mulDivObj := by pre_dcp #print mulDivObjAuto -- mul_div (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulDivObj | null |
mulDivConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (sqrt x) * (sqrt x / 2) ≤ 1 time_cmd equivalence mulDivConstrRed/mulDivConstrAuto : mulDivConstr := by pre_dcp #print mulDivConstrAuto -- mul_div-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulDivConstr | null |
mulDivRevObj := optimization (x y : ℝ) minimize ((x * y) / x : ℝ) subject to hx : 0 < x time_cmd equivalence mulDivRevObjRed/mulDivRevObjAuto : mulDivRevObj := by pre_dcp #print mulDivRevObjAuto -- mul_div-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulDivRevObj | null |
mulDivRevConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (x * y) / x ≤ 1 time_cmd equivalence mulDivRevConstrRed/mulDivRevConstrAuto : mulDivRevConstr := by pre_dcp #print mulDivRevConstrAuto -- div_self (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulDivRevConstr | null |
divSelfObj := optimization (x y : ℝ) minimize ((x / x) * y : ℝ) subject to hx : 0 < x time_cmd equivalence divSelfObjRed/divSelfObjAuto : divSelfObj := by pre_dcp #print divSelfObjAuto -- div_self (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divSelfObj | null |
divSelfConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (x / x) * y ≤ 1 time_cmd equivalence divSelfConstrRed/divSelfConstrAuto : divSelfConstr := by pre_dcp #print divSelfConstrAuto /- Power and square root rules. -/ -- pow_add-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divSelfConstr | null |
powAddRevObj := optimization (x : ℝ) minimize ((sqrt x) * (sqrt x) : ℝ) subject to hx : 0 < x time_cmd equivalence powAddRevObjRed/powAddRevObjAuto : powAddRevObj := by pre_dcp #print powAddRevObjAuto -- pow_add-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powAddRevObj | null |
powAddRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (sqrt x) * (sqrt x) ≤ 1 time_cmd equivalence powAddRevConstrRed/powAddRevConstrAuto : powAddRevConstr := by pre_dcp #print powAddRevConstrAuto -- mul_pow (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powAddRevConstr | null |
mulPowObj := optimization (x : ℝ) minimize ((x * (sqrt x)) ^ (2 : ℝ) / x : ℝ) subject to hx : 0 < x time_cmd equivalence mulPowObjRed/mulPowObjAuto : mulPowObj := by pre_dcp #print mulPowObjAuto -- mul_pow (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulPowObj | null |
mulPowConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : ((x * (sqrt x)) ^ (2 : ℝ) / x) ≤ 1 time_cmd equivalence mulPowConstrRed/mulPowConstrAuto : mulPowConstr := by pre_dcp #print mulPowConstrAuto -- mul_pow-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulPowConstr | null |
mulPowRevObj := optimization (x : ℝ) minimize (((sqrt x) ^ (2 : ℝ)) * ((sqrt (x + 1)) ^ (2 : ℝ)) : ℝ) subject to hx : 0 < x time_cmd equivalence mulPowRevObjRed/mulPowRevObjAuto : mulPowRevObj := by pre_dcp #print mulPowRevObjAuto -- mul_pow-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulPowRevObj | null |
mulPowRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (((sqrt x) ^ (2 : ℝ)) * ((sqrt (x + 1)) ^ (2 : ℝ))) ≤ 1 time_cmd equivalence mulPowRevConstrRed/mulPowRevConstrAuto : mulPowRevConstr := by pre_dcp #print mulPowRevConstrAuto -- pow_mul-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | mulPowRevConstr | null |
powMulRevObj := optimization (x : ℝ) minimize ((x ^ (1 : ℝ)) ^ (2 : ℝ) : ℝ) subject to hx : 0 < x time_cmd equivalence powMulRevObjRed/powMulRevObjAuto : powMulRevObj := by pre_dcp #print powMulRevObjAuto -- pow_mul-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powMulRevObj | null |
powMulRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : ((x ^ (2 : ℝ)) ^ (2 : ℝ)) ≤ 1 time_cmd equivalence powMulRevConstrRed/powMulRevConstrAuto : powMulRevConstr := by pre_dcp #print powMulRevConstrAuto -- div_pow (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powMulRevConstr | null |
divPowObj := optimization (x : ℝ) minimize ((x ^ (2 : ℝ)) * (1 / x) ^ (2 : ℝ) : ℝ) subject to hx : 0 < x time_cmd equivalence divPowObjRed/divPowObjAuto : divPowObj := by pre_dcp #print divPowObjAuto -- div_pow (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowObj | null |
divPowConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (1 / x) ^ (2 : ℝ) ≤ 1 time_cmd equivalence divPowConstrRed/divPowConstrAuto : divPowConstr := by pre_dcp #print divPowConstrAuto -- div_pow-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowConstr | null |
divPowRevObj := optimization (x : ℝ) minimize ((x + x) ^ (2 : ℝ) / x ^ (2 : ℝ) : ℝ) subject to hx : 0 < x time_cmd equivalence divPowRevObjRed/divPowRevObjAuto : divPowRevObj := by pre_dcp #print divPowRevObjAuto -- div_pow-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowRevObj | null |
divPowRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : ((x + x) ^ (2 : ℝ) / x ^ (2 : ℝ)) ≤ x time_cmd equivalence divPowRevConstrRed/divPowRevConstrAuto : divPowRevConstr := by pre_dcp #print divPowRevConstrAuto -- pow_sub-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowRevConstr | null |
powSubRevObj := optimization (x : ℝ) minimize ((x ^ (2 : ℝ)) / (sqrt x) : ℝ) subject to hx : 0 < x time_cmd equivalence powSubRevObjRed/powSubRevObjAuto : powSubRevObj := by pre_dcp #print powSubRevObjAuto -- pow_sub-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powSubRevObj | null |
powSubRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : ((x ^ (2 : ℝ)) / (sqrt x)) ≤ 1 time_cmd equivalence powSubRevConstrRed/powSubRevConstrAuto : powSubRevConstr := by pre_dcp #print powSubRevConstrAuto -- div_pow_eq_mul_pow_neg (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powSubRevConstr | null |
divPowEqMulPowNegObj := optimization (x : ℝ) minimize (1 / (x ^ (2 : ℝ)) : ℝ) subject to hx : 0 < x time_cmd equivalence divPowEqMulPowNegObjRed/divPowEqMulPowNegObjAuto : divPowEqMulPowNegObj := by pre_dcp #print divPowEqMulPowNegObjAuto -- div_pow_eq_mul_pow_neg (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowEqMulPowNegObj | null |
divPowEqMulPowNegConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : 1 / (x ^ (2 : ℝ)) ≤ 1 time_cmd equivalence divPowEqMulPowNegConstrRed/divPowEqMulPowNegConstrAuto : divPowEqMulPowNegConstr := by pre_dcp #print divPowEqMulPowNegConstrAuto -- one_div_eq_pow_neg_one (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | divPowEqMulPowNegConstr | null |
oneDivEqPowNegOneObj := optimization (x : ℝ) minimize (1 / (sqrt x) : ℝ) subject to hx : 0 < x time_cmd equivalence oneDivEqPowNegOneObjRed/oneDivEqPowNegOneObjAuto : oneDivEqPowNegOneObj := by pre_dcp #print oneDivEqPowNegOneObjAuto -- one_div_eq_pow_neg_one (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneDivEqPowNegOneObj | null |
oneDivEqPowNegOneConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : 1 / (sqrt x) ≤ 1 time_cmd equivalence oneDivEqPowNegOneConstrRed/oneDivEqPowNegOneConstrAuto : oneDivEqPowNegOneConstr := by pre_dcp #print oneDivEqPowNegOneConstrAuto -- sqrt_eq_rpow (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | oneDivEqPowNegOneConstr | null |
sqrtEqRpowObj := optimization (x : ℝ) minimize ((sqrt x) * (sqrt x) : ℝ) subject to hx : 0 < x time_cmd equivalence sqrtEqRpowObjRed/sqrtEqRpowObjAuto : sqrtEqRpowObj := by pre_dcp #print sqrtEqRpowObjAuto -- sqrt_eq_rpow (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | sqrtEqRpowObj | null |
sqrtEqRpowConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (sqrt x) * (sqrt x) ≤ 1 time_cmd equivalence sqrtEqRpowConstrRed/sqrtEqRpowConstrAuto : sqrtEqRpowConstr := by pre_dcp #print sqrtEqRpowConstrAuto -- pow_half_two (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | sqrtEqRpowConstr | null |
powHalfTwoObj := optimization (x : ℝ) minimize ((sqrt x) ^ (2 : ℝ) : ℝ) subject to hx : 0 < x time_cmd equivalence powHalfTwoObjRed/powHalfTwoObjAuto : powHalfTwoObj := by pre_dcp #print powHalfTwoObjAuto -- pow_half_two (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powHalfTwoObj | null |
powHalfTwoConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : (sqrt x) ^ (2 : ℝ) ≤ 1 time_cmd equivalence powHalfTwoConstrRed/powHalfTwoConstrAuto : powHalfTwoConstr := by pre_dcp #print powHalfTwoConstrAuto /- Exponential and logarithm rules. -/ -- exp_add (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | powHalfTwoConstr | null |
expAddObj := optimization (x : ℝ) minimize (exp ((log x) + 2) : ℝ) subject to hx : 0 < x time_cmd equivalence expAddObjRed/expAddObjAuto : expAddObj := by pre_dcp #print expAddObjAuto -- exp_add (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expAddObj | null |
expAddConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp ((log x) + 2) ≤ 10 time_cmd equivalence expAddConstrRed/expAddConstrAuto : expAddConstr := by pre_dcp #print expAddConstrAuto -- exp_add-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expAddConstr | null |
expAddRevObj := optimization (x y : ℝ) minimize (exp x * exp x : ℝ) subject to hx : 0 < x time_cmd equivalence expAddRevObjRed/expAddRevObjAuto : expAddRevObj := by pre_dcp #print expAddRevObjAuto -- exp_add-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expAddRevObj | null |
expAddRevConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp x * exp x ≤ 1 time_cmd equivalence expAddRevConstrRed/expAddRevConstrAuto : expAddRevConstr := by pre_dcp #print expAddRevConstrAuto -- exp_sub (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expAddRevConstr | null |
expSubObj := optimization (x : ℝ) minimize (exp ((log x) - 2) : ℝ) subject to hx : 0 < x time_cmd equivalence expSubObjRed/expSubObjAuto : expSubObj := by pre_dcp #print expSubObjAuto -- exp_sub (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expSubObj | null |
expSubConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp ((log x) - 2) ≤ 1 time_cmd equivalence expSubConstrRed/expSubConstrAuto : expSubConstr := by pre_dcp #print expSubConstrAuto -- exp_sub-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expSubConstr | null |
expSubRevObj := optimization (x y : ℝ) minimize (exp (2 * x) / exp x : ℝ) subject to hx : 0 < x time_cmd equivalence expSubRevObjRed/expSubRevObjAuto : expSubRevObj := by pre_dcp #print expSubRevObjAuto -- exp_sub-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expSubRevObj | null |
expSubRevConstr := optimization (x y : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp (2 * x) / exp x ≤ 1 time_cmd equivalence expSubRevConstrRed/expSubRevConstrAuto : expSubRevConstr := by pre_dcp #print expSubRevConstrAuto -- exp_mul (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expSubRevConstr | null |
expMulObj := optimization (x : ℝ) minimize (exp (log x * 2) : ℝ) subject to hx : 0 < x time_cmd equivalence expMulObjRed/expMulObjAuto : expMulObj := by pre_dcp #print expMulObjAuto -- exp_mul (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expMulObj | null |
expMulConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp (log x * 2) ≤ 1 time_cmd equivalence expMulConstrRed/expMulConstrAuto : expMulConstr := by pre_dcp #print expMulConstrAuto -- exp_mul-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expMulConstr | null |
expMulRevObj := optimization (x : ℝ) minimize ((exp x) ^ (2 : ℝ) : ℝ) subject to hx : 0 < x time_cmd equivalence expMulRevObjRed/expMulRevObjAuto : expMulRevObj := by pre_dcp #print expMulRevObjAuto -- exp_mul-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expMulRevObj | null |
expMulRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : ((exp x) ^ (2 : ℝ)) ≤ 1 time_cmd equivalence expMulRevConstrRed/expMulRevConstrAuto : expMulRevConstr := by pre_dcp #print expMulRevConstrAuto -- exp_neg_eq_one_div (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expMulRevConstr | null |
expNegEqOneDivObj := optimization (x : ℝ) minimize (x * exp (-(log x)) : ℝ) subject to h : 1 ≤ x time_cmd equivalence expNegEqOneDivObjRed/expNegEqOneDivObjAuto : expNegEqOneDivObj := by pre_dcp #print expNegEqOneDivObjAuto -- exp_neg_eq_one_div (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expNegEqOneDivObj | null |
expNegEqOneDivConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : x * exp (-(log x)) ≤ x time_cmd equivalence expNegEqOneDivConstrRed/expNegEqOneDivConstrAuto : expNegEqOneDivConstr := by pre_dcp #print expNegEqOneDivConstrAuto -- exp_neg_eq_one_div-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expNegEqOneDivConstr | null |
expNegEqOneDivRevObj := optimization (x : ℝ) minimize (1 / (exp x)) subject to h : 1 ≤ x time_cmd equivalence expNegEqOneDivRevObjRed/expNegEqOneDivRevObjAuto : expNegEqOneDivRevObj := by pre_dcp #print expNegEqOneDivRevObjAuto -- exp_neg_eq_one_div-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expNegEqOneDivRevObj | null |
expNegEqOneDivRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : 1 / (exp x) ≤ 1 time_cmd equivalence expNegEqOneDivRevConstrRed/expNegEqOneDivRevConstrAuto : expNegEqOneDivRevConstr := by pre_dcp #print expNegEqOneDivRevConstrAuto -- log_mul (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expNegEqOneDivRevConstr | null |
logMulObj := optimization (x : ℝ) minimize (- log (x * x) : ℝ) subject to hx : 0 < x time_cmd equivalence logMulObjRed/logMulObjAuto : logMulObj := by pre_dcp #print logMulObjAuto -- log_mul (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logMulObj | null |
logMulConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : 1 ≤ log (x * x) time_cmd equivalence logMulConstrRed/logMulConstrAuto : logMulConstr := by pre_dcp #print logMulConstrAuto -- log_mul-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logMulConstr | null |
logMulRevObj := optimization (x : ℝ) minimize (exp (log x + log (x + 1))) subject to hx : 0 < x time_cmd equivalence logMulRevObjRed/logMulRevObjAuto : logMulRevObj := by pre_dcp #print logMulRevObjAuto -- log_mul-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logMulRevObj | null |
logMulRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp (log x + log (x + 1)) ≤ 1 time_cmd equivalence logMulRevConstrRed/logMulRevConstrAuto : logMulRevConstr := by pre_dcp #print logMulRevConstrAuto -- log_div (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logMulRevConstr | null |
logDivObj := optimization (x : ℝ) minimize (log ((exp x) / x) : ℝ) subject to hx : 0 < x time_cmd equivalence logDivObjRed/logDivObjAuto : logDivObj := by pre_dcp #print logDivObjAuto -- log_div (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logDivObj | null |
logDivConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : log ((exp x) / x) ≤ 1 time_cmd equivalence logDivConstrRed/logDivConstrAuto : logDivConstr := by pre_dcp #print logDivConstrAuto -- log_div-rev (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logDivConstr | null |
logDivRevObj := optimization (x : ℝ) minimize (- (log (x ^ (2 : ℝ)) - log x)) subject to hx : 0 < x time_cmd equivalence logDivRevObjRed/logDivRevObjAuto : logDivRevObj := by pre_dcp #print logDivRevObjAuto -- log_div-rev (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logDivRevObj | null |
logDivRevConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : - (log (x ^ (2 : ℝ)) - log x) ≤ 1 time_cmd equivalence logDivRevConstrRed/logDivRevConstrAuto : logDivRevConstr := by pre_dcp #print logDivRevConstrAuto -- exp_log (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logDivRevConstr | null |
expLogObj := optimization (x : ℝ) minimize (exp (log x) : ℝ) subject to hx : 0 < x time_cmd equivalence expLogObjRed/expLogObjAuto : expLogObj := by pre_dcp #print expLogObjAuto -- exp_log (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expLogObj | null |
expLogConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to hx : 0 < x h : exp (log x) ≤ 1 time_cmd equivalence expLogConstrRed/expLogConstrAuto : expLogConstr := by pre_dcp #print expLogConstrAuto -- log_exp (obj) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | expLogConstr | null |
logExpObj := optimization (x : ℝ) minimize (log (exp x) : ℝ) subject to hx : 0 ≤ x time_cmd equivalence logExpObjRed/logExpObjAuto : logExpObj := by pre_dcp #print logExpObjAuto -- log_exp (constr) | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logExpObj | null |
logExpConstr := optimization (x : ℝ) minimize (0 : ℝ) subject to h : log (exp x) ≤ 1 time_cmd equivalence logExpConstrRed/logExpConstrAuto : logExpConstr := by pre_dcp #print logExpConstrAuto | def | CvxLean | [
"import CvxLean.Command.Solve",
"import CvxLean.Command.Reduction",
"import CvxLean.Command.Equivalence",
"import CvxLean.Command.Util.TimeCmd",
"import CvxLean.Tactic.Basic.ChangeOfVariables",
"import CvxLean.Tactic.PreDCP.PreDCP"
] | CvxLean/Test/PreDCP/Unit.lean | logExpConstr | null |
A : ℝ := 1 #real_to_float A | def | CvxLean | [
"import CvxLean.Lib.Minimization",
"import CvxLean.Syntax.OptimizationParam",
"import CvxLean.Command.Solve.Float.RealToFloatLibrary"
] | CvxLean/Test/Solve/RealToFloat.lean | A | null |
B : ℝ := 1 #real_to_float B | def | CvxLean | [
"import CvxLean.Lib.Minimization",
"import CvxLean.Syntax.OptimizationParam",
"import CvxLean.Command.Solve.Float.RealToFloatLibrary"
] | CvxLean/Test/Solve/RealToFloat.lean | B | null |
exp1 := optimization (x : ℝ) maximize (x) subject to h : exp x ≤ 10 solve exp1 #print exp1.conicForm #eval exp1.status -- "PRIMAL_AND_DUAL_FEASIBLE" #eval exp1.value -- 2.302585 #eval exp1.solution -- 2.302585 | def | CvxLean | [
"import CvxLean.Command.Solve"
] | CvxLean/Test/Solve/Problems/Exp.lean | exp1 | null |
exp2 := optimization (x : ℝ) minimize (exp x) subject to h : 10 ≤ x solve exp2 #print exp2.conicForm #eval exp2.status -- "PRIMAL_AND_DUAL_FEASIBLE" #eval exp2.value -- 22026.464907 #eval exp2.solution -- 10.000000 | def | CvxLean | [
"import CvxLean.Command.Solve"
] | CvxLean/Test/Solve/Problems/Exp.lean | exp2 | null |
linear1 := optimization (x : ℝ) maximize (7 * x + 1) subject to h : 2 * x ≤ 3 solve linear1 #print linear1.conicForm #eval linear1.status -- "PRIMAL_AND_DUAL_FEASIBLE" #eval linear1.value -- 11.500000 #eval linear1.solution -- 1.500000 | def | CvxLean | [
"import CvxLean.Command.Solve"
] | CvxLean/Test/Solve/Problems/Linear.lean | linear1 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.