Source file nsatz.ml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
open CErrors
open Util
open Constr
open Tactics
open Utile
module BigInt = struct
open Big_int_Z
type t = big_int
let of_int = big_int_of_int
let coef0 = of_int 0
let of_num = Q.to_bigint
let to_num = Q.of_bigint
let equal = eq_big_int
let lt = lt_big_int
let le = le_big_int
let abs = abs_big_int
let plus =add_big_int
let mult = mult_big_int
let sub = sub_big_int
let opp = minus_big_int
let div = div_big_int
let modulo = mod_big_int
let to_string = string_of_big_int
let hash x =
try (int_of_big_int x)
with Failure _ -> 1
let puis = power_big_int_positive_int
let rec pgcd a b =
if equal b coef0
then a
else if lt a b then pgcd b a else pgcd b (modulo a b)
end
type vname = string
type term =
| Zero
| Const of Q.t
| Var of vname
| Opp of term
| Add of term * term
| Sub of term * term
| Mul of term * term
| Pow of term * int
let const n =
if Q.(equal zero) n then Zero else Const n
let pow(p,i) = if Int.equal i 1 then p else Pow(p,i)
let add = function
(Zero,q) -> q
| (p,Zero) -> p
| (p,q) -> Add(p,q)
let mul = function
(Zero,_) -> Zero
| (_,Zero) -> Zero
| (p,Const n) when Q.(equal one) n -> p
| (Const n,q) when Q.(equal one) n -> q
| (p,q) -> Mul(p,q)
let gen_constant n = lazy (UnivGen.constr_of_monomorphic_global (Global.env ()) (Coqlib.lib_ref n))
let tpexpr = gen_constant "plugins.ring.pexpr"
let ttconst = gen_constant "plugins.ring.const"
let ttvar = gen_constant "plugins.ring.var"
let ttadd = gen_constant "plugins.ring.add"
let ttsub = gen_constant "plugins.ring.sub"
let ttmul = gen_constant "plugins.ring.mul"
let ttopp = gen_constant "plugins.ring.opp"
let ttpow = gen_constant "plugins.ring.pow"
let tlist = gen_constant "core.list.type"
let lnil = gen_constant "core.list.nil"
let lcons = gen_constant "core.list.cons"
let tz = gen_constant "num.Z.type"
let z0 = gen_constant "num.Z.Z0"
let zpos = gen_constant "num.Z.Zpos"
let zneg = gen_constant "num.Z.Zneg"
let pxI = gen_constant "num.pos.xI"
let pxO = gen_constant "num.pos.xO"
let pxH = gen_constant "num.pos.xH"
let nN0 = gen_constant "num.N.N0"
let nNpos = gen_constant "num.N.Npos"
let mkt_app name l = mkApp (Lazy.force name, Array.of_list l)
let tlp () = mkt_app tlist [mkt_app tpexpr [Lazy.force tz]]
let tllp () = mkt_app tlist [tlp()]
let mkt_pos n =
let rec mkt_pos n =
if Z.(equal one) n then Lazy.force pxH
else if Z.is_even n then
mkt_app pxO [mkt_pos Z.(n asr 1)]
else
mkt_app pxI [mkt_pos Z.(n asr 1)]
in mkt_pos (Q.to_bigint n)
let mkt_n n =
if Q.(equal zero) n
then Lazy.force nN0
else mkt_app nNpos [mkt_pos n]
let mkt_z z =
if Q.(equal zero) z then Lazy.force z0
else if Q.(lt zero) z then
mkt_app zpos [mkt_pos z]
else
mkt_app zneg [mkt_pos (Q.neg z)]
let rec mkt_term t = match t with
| Zero -> mkt_term (Const Q.zero)
| Const r -> let n = r |> Q.num |> Q.of_bigint in
mkt_app ttconst [Lazy.force tz; mkt_z n]
| Var v -> mkt_app ttvar [Lazy.force tz; mkt_pos (Q.of_string v)]
| Opp t1 -> mkt_app ttopp [Lazy.force tz; mkt_term t1]
| Add (t1,t2) -> mkt_app ttadd [Lazy.force tz; mkt_term t1; mkt_term t2]
| Sub (t1,t2) -> mkt_app ttsub [Lazy.force tz; mkt_term t1; mkt_term t2]
| Mul (t1,t2) -> mkt_app ttmul [Lazy.force tz; mkt_term t1; mkt_term t2]
| Pow (t1,n) -> if Int.equal n 0 then
mkt_app ttconst [Lazy.force tz; mkt_z Q.one]
else
mkt_app ttpow [Lazy.force tz; mkt_term t1; mkt_n (Q.of_int n)]
let rec parse_pos p =
match Constr.kind p with
| App (a,[|p2|]) ->
if Constr.equal a (Lazy.force pxO) then Q.(mul (of_int 2)) (parse_pos p2)
else Q.(add one) Q.(mul (of_int 2) (parse_pos p2))
| _ -> Q.one
let parse_z z =
match Constr.kind z with
| App (a,[|p2|]) ->
if Constr.equal a (Lazy.force zpos) then parse_pos p2 else Q.neg (parse_pos p2)
| _ -> Q.zero
let parse_n z =
match Constr.kind z with
| App (a,[|p2|]) ->
parse_pos p2
| _ -> Q.zero
let rec parse_term p =
match Constr.kind p with
| App (a,[|_;p2|]) ->
if Constr.equal a (Lazy.force ttvar) then Var (Q.to_string (parse_pos p2))
else if Constr.equal a (Lazy.force ttconst) then Const (parse_z p2)
else if Constr.equal a (Lazy.force ttopp) then Opp (parse_term p2)
else Zero
| App (a,[|_;p2;p3|]) ->
if Constr.equal a (Lazy.force ttadd) then Add (parse_term p2, parse_term p3)
else if Constr.equal a (Lazy.force ttsub) then Sub (parse_term p2, parse_term p3)
else if Constr.equal a (Lazy.force ttmul) then Mul (parse_term p2, parse_term p3)
else if Constr.equal a (Lazy.force ttpow) then
Pow (parse_term p2, Q.to_int (parse_n p3))
else Zero
| _ -> Zero
let rec parse_request lp =
match Constr.kind lp with
| App (_,[|_|]) -> []
| App (_,[|_;p;lp1|]) ->
(parse_term p)::(parse_request lp1)
|_-> assert false
let set_nvars_term nvars t =
let rec aux t nvars =
match t with
| Zero -> nvars
| Const r -> nvars
| Var v -> let n = int_of_string v in
max nvars n
| Opp t1 -> aux t1 nvars
| Add (t1,t2) -> aux t2 (aux t1 nvars)
| Sub (t1,t2) -> aux t2 (aux t1 nvars)
| Mul (t1,t2) -> aux t2 (aux t1 nvars)
| Pow (t1,n) -> aux t1 nvars
in aux t nvars
module Coef = BigInt
module Poly = Polynom.Make(Coef)
module PIdeal = Ideal.Make(Poly)
open PIdeal
let term_pol_sparse nvars np t=
let d = nvars in
let rec aux t =
let res =
match t with
| Zero -> zeroP
| Const r ->
if Q.(equal zero) r
then zeroP
else polconst d (Poly.Pint (Coef.of_num r))
| Var v ->
let v = int_of_string v in
if v <= np
then polconst d (Poly.x v)
else gen d v
| Opp t1 -> oppP (aux t1)
| Add (t1,t2) -> plusP (aux t1) (aux t2)
| Sub (t1,t2) -> plusP (aux t1) (oppP (aux t2))
| Mul (t1,t2) -> multP (aux t1) (aux t2)
| Pow (t1,n) -> puisP (aux t1) n
in
res
in
let res= aux t in
res
let polrec_to_term p =
let rec aux p =
match p with
|Poly.Pint n -> const (Coef.to_num n)
|Poly.Prec (v,coefs) ->
let fold i c res = add (res, mul (aux c, pow (Var (string_of_int v), i))) in
Array.fold_right_i fold coefs Zero
in aux p
let pol_sparse_to_term n2 p =
let p = PIdeal.repr p in
let rec aux p =
match p with
[] -> const Q.zero
| (a,m)::p1 ->
let m = Ideal.Monomial.repr m in
let n = (Array.length m)-1 in
let (i0,e0) =
List.fold_left (fun (r,d) (a,m) ->
let m = Ideal.Monomial.repr m in
let i0= ref 0 in
for k=1 to n do
if m.(k)>0
then i0:=k
done;
if Int.equal !i0 0
then (r,d)
else if !i0 > r
then (!i0, m.(!i0))
else if Int.equal !i0 r && m.(!i0)<d
then (!i0, m.(!i0))
else (r,d))
(0,0)
p in
if Int.equal i0 0
then
let mp = polrec_to_term a in
if List.is_empty p1 then mp else add (mp, aux p1)
else
let fold (p1, p2) (a, m) =
if (Ideal.Monomial.repr m).(i0) >= e0 then begin
let m0 = Array.copy (Ideal.Monomial.repr m) in
let () = m0.(i0) <- m0.(i0) - e0 in
let m0 = Ideal.Monomial.make m0 in
((a, m0) :: p1, p2)
end else
(p1, (a, m) :: p2)
in
let (p1, p2) = List.fold_left fold ([], []) p in
let vm =
if Int.equal e0 1
then Var (string_of_int (i0))
else pow (Var (string_of_int (i0)),e0) in
add (mul(vm, aux (List.rev p1)), aux (List.rev p2))
in
aux p
let remove_zeros lci =
let m = List.length lci in
let u = Array.make m false in
let rec utiles k =
if k >= m || u.(k) then ()
else
let () = u.(k) <- true in
let lc = List.nth lci k in
let iter i c = if not (PIdeal.equal c zeroP) then utiles (i + k + 1) in
List.iteri iter lc
in
let () = utiles 0 in
let filter i l =
let f j l = if m <= i + j + 1 then true else u.(i + j + 1) in
if u.(i) then Some (List.filteri f l)
else None
in
let lr = CList.map_filter_i filter lci in
info (fun () -> Printf.sprintf "useless spolynomials: %i" (m-List.length lr));
info (fun () -> Printf.sprintf "useful spolynomials: %i " (List.length lr));
lr
let theoremedeszeros metadata nvars lpol p =
let t1 = Unix.gettimeofday() in
let m = nvars in
let cert = in_ideal metadata m lpol p in
info (fun () -> Printf.sprintf "time: @[%10.3f@]s" (Unix.gettimeofday ()-.t1));
cert
open Ideal
let clean_pol lp =
let t = Hashpol.create 12 in
let find p = try Hashpol.find t p
with
Not_found -> Hashpol.add t p true; false in
let rec aux lp =
match lp with
| [] -> [], []
| p :: lp1 ->
let clp, lb = aux lp1 in
if equal p zeroP || find p then clp, true::lb
else
(p :: clp, false::lb) in
aux lp
let expand_pol lb lp =
let rec aux lb lp =
match lb with
| [] -> lp
| true :: lb1 -> zeroP :: aux lb1 lp
| false :: lb1 ->
match lp with
[] -> assert false
| p :: lp1 -> p :: aux lb1 lp1
in List.rev (aux lb (List.rev lp))
let theoremedeszeros_termes lp =
let nvars = List.fold_left set_nvars_term 0 lp in
match lp with
| Const sugarparam :: Const nparam :: lp ->
let nparam = Q.to_int nparam in
((match Q.to_int sugarparam with
|0 -> sinfo "computation without sugar";
lexico:=false;
|1 -> sinfo "computation with sugar";
lexico:=false;
|2 -> sinfo "ordre lexico computation without sugar";
lexico:=true;
|3 -> sinfo "ordre lexico computation with sugar";
lexico:=true;
|4 -> sinfo "computation without sugar, division by pairs";
lexico:=false;
|5 -> sinfo "computation with sugar, division by pairs";
lexico:=false;
|6 -> sinfo "ordre lexico computation without sugar, division by pairs";
lexico:=true;
|7 -> sinfo "ordre lexico computation with sugar, division by pairs";
lexico:=true;
| _ -> user_err Pp.(str "nsatz: bad parameter")
);
let lvar = List.init nvars (fun i -> Printf.sprintf "x%i" (i + 1)) in
let lvar = ["a";"b";"c";"d";"e";"f";"g";"h";"i";"j";"k";"l";"m";"n";"o";"p";"q";"r";"s";"t";"u";"v";"w";"x";"y";"z"] @ lvar in
let metadata = { name_var = lvar } in
let lp = List.map (term_pol_sparse nvars nparam) lp in
match lp with
| [] -> assert false
| p::lp1 ->
let lpol = List.rev lp1 in
let lpol, lb = clean_pol lpol in
let cert = theoremedeszeros metadata nvars lpol p in
sinfo "cert ok";
let lc = cert.last_comb::List.rev cert.gb_comb in
match remove_zeros lc with
| [] -> assert false
| (lq::lci) ->
let lq = expand_pol lb lq in
let m = nvars in
let c = pol_sparse_to_term m (polconst m cert.coef) in
let r = Pow(Zero,cert.power) in
let lci = List.rev lci in
let lci = List.map (expand_pol lb) lci in
let lci = List.map (List.map (pol_sparse_to_term m)) lci in
let lq = List.map (pol_sparse_to_term m) lq in
info (fun () -> Printf.sprintf "number of parameters: %i" nparam);
sinfo "term computed";
(c,r,lci,lq)
)
|_ -> assert false
let nsatz lpol =
let lp= parse_request lpol in
let (c,r,lci,lq) = theoremedeszeros_termes lp in
let res = [c::r::lq]@lci in
let res = List.map (fun lx -> List.map mkt_term lx) res in
let res =
List.fold_right
(fun lt r ->
let ltterm =
List.fold_right
(fun t r ->
mkt_app lcons [mkt_app tpexpr [Lazy.force tz];t;r])
lt
(mkt_app lnil [mkt_app tpexpr [Lazy.force tz]]) in
mkt_app lcons [tlp ();ltterm;r])
res
(mkt_app lnil [tlp ()]) in
sinfo "term computed";
res
let return_term t =
let a =
mkApp (UnivGen.constr_of_monomorphic_global (Global.env ()) @@ Coqlib.lib_ref "core.eq.refl",[|tllp ();t|]) in
let a = EConstr.of_constr a in
generalize [a]
let nsatz_compute t =
let lpol =
try nsatz t
with Ideal.NotInIdeal ->
user_err Pp.(str "nsatz cannot solve this problem") in
return_term lpol